关于 JAVA 高级-反射机制-获取类对象的所有提问

2021-03-15 类对象

森大大	关于 JAVA 高级-反射机制-获取类对象的提问类对象的用处是什么

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2021-02-05 不用synchronized会怎样

一叶秋梦	关于 JAVA 高级-反射机制-获取类对象 -答案-在静态方法上加synchronized，同步对象是什么？的提问有没有synchronized运行起来没有什么区别啊？

2 个答案

fql
答案时间：2021-09-21

package JavaSeHigh.reflection; public class TestReflection_synchronized { } class TestReflection3 { public static void main(String[] args) throws InterruptedException { Thread t1= new Thread(){ public void run(){ //调用method1 TestReflection3.method1(); } }; t1.setName("第一个线程"); t1.start(); //保证第一个线程先调用method1 Thread.sleep(1000); Thread t2= new Thread(){ public void run(){ //调用method2 TestReflection3.method2(); } }; t2.setName("第二个线程"); t2.start(); Thread t3= new Thread(){ public void run(){ //调用method2 TestReflection3.method3(); } }; t3.setName("第三个线程调皮闯入"); t3.start(); } public static void method1() { synchronized (TestReflection3.class) { // 对于method1而言，同步对象是TestReflection3.class，只有占用TestReflection.class才可以执行到这里 System.out.println(Thread.currentThread().getName() + " 进入了method1方法"); try { System.out.println("运行15秒"); Thread.sleep(15000); System.out.println("method1方法结束"); } catch (InterruptedException e) { e.printStackTrace(); } } } public static synchronized void method2() { // 对于mehotd2而言，必然有个同步对象，通过观察发现，当某个线程在method1中，占用了TestReflection.class之后 // 就无法进入method2，推断出，method2的同步对象，就是TestReflection.class System.out.println(Thread.currentThread().getName() + " 进入了method2方法"); try { System.out.println("运行3秒"); Thread.sleep(3000); System.out.println("method2方法结束"); } catch (InterruptedException e) { e.printStackTrace(); } } public static void method3() { // 对于mehotd2而言，必然有个同步对象，通过观察发现，当某个线程在method1中，占用了TestReflection.class之后 // 就无法进入method2，推断出，method2的同步对象，就是TestReflection.class System.out.println(Thread.currentThread().getName() + " 进入了method3方法"); try { System.out.println("嘤嘤嘤~~~没加synchronized，我在这里捣乱3秒"); Thread.sleep(3000); System.out.println("method3方法结束，拜拜~"); } catch (InterruptedException e) { e.printStackTrace(); } } }

海心
答案时间：2021-03-03

你把method1睡眠时间改为20s 你再看看。再进一步在sleep后分别加入System.out.println("method1结束"); System.out.println("method2结束"); 可以看到method2一定在method1执行完才开始执行。而method2没加synchronized时，method2在method1未完成前就执行。 --------------method2加synchronized时------------------------ 第一个线程进入了method1方法运行20秒 method1结束第二个线程进入了method2方法运行5秒 method2结束 -------------------------------------------- --------------method2没加synchronized时------------------------ 第一个线程进入了method1方法运行20秒第二个线程进入了method2方法运行5秒 method2结束 method1结束 --------------------------------------------

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2020-11-20 站长，这个侵犯了您的版权

yimoxc

关于 JAVA 高级-反射机制-获取类对象 -什么是类对象的提问

站长，他们这是侵权了吗？这不会对你的网站有影响吗？

4 个答案

Carms
答案时间：2021-04-13

这个离线包站内也有，是为了给大学生有时候会断网提供的

云天灬
答案时间：2021-01-20

其实你错了，没有侵权

wdwxwh
答案时间：2021-01-11

我也下载过这个离线包， 500多M

夕阳无限好
答案时间：2020-12-05

如果你在站内下载过这个离线包你就知道原因

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2020-10-03 静态方法前加synchronized

qazwsxc

关于 JAVA 高级-反射机制-获取类对象的提问

同步的是当前类对象

public class Test {
    public static void main(String[] args) {
        for (int i=0;i<20;i++){
            Thread thread=new Thread(){
                @Override
                public void run() {
                    Test.test();
                }
            };
            thread.start();
        }
    }
    //不加synchronized，是多个线程直接输出20次
    //加上synchronized，线程同步输出
    //在静态方法前面加synchronized，同步对象是当前类对象
    public synchronized static void test(){
        System.out.println("a");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2020-07-28 hero.getClass 和new hero().getClass 有什么不一样？

2020-07-25 这里说的静态方法是指静态代码块？还是被static修饰的方法？

2020-05-19 关于Class与Class?<?>

2020-03-15 这个答案没有积分了怎么查看啊？？？也没有地方可以买这个高级教程的呀

2020-01-29 在静态方法前面加synchronize，其同步对象是当前类对象

关外栈

关于 JAVA 高级-反射机制-获取类对象的提问

/* * 经过测试： * 1. 不加 synchronized 的情况下，直接执行程序，println 里的内容会直接输出20次 * 2. 加 synchronized 的情况下，执行程序，println里的内容每输出一次就暂停5秒钟 * 结论： * 在静态方法前面加synchronize，其同步对象是当前类对象 * */

package com.hyh.test;

import com.hyh.pojo.Hero;

/**
 * @Auther: He YongHui
 * 2020/1/29 17:13:04
 */
public class Test {
    public static void main(String[] args) {

        for (int i = 0; i < 20; i++) {
            Thread t = new Thread(){

                @Override
                public void run() {
                    Test.test();
                }
            };

            t.start();
        }
    }

    /*
    * 经过测试：
    *   1. 不加 synchronized 的情况下，直接执行程序，println 里的内容会直接输出20次
    *   2. 加 synchronized 的情况下，执行程序，println里的内容每输出一次就暂停5秒钟
    *   结论：
    *   在静态方法前面加synchronize，其同步对象是 当前类对象
    * */
    public synchronized static void test() {
        System.out.println("test方法启动,并休眠5秒钟");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

}

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2019-12-21 在静态方法前面加synchronize

2019-11-22 练习

尹文

关于 JAVA 高级-反射机制-获取类对象的提问

对类方法的同步块，会占用当前类对象作为同步对象

package reflection;

public class Test2 {
	public static void main(String[] args) throws InterruptedException {
		Thread thread1 = new Thread(){
			public void run() {
				method1();
			};
		};
		thread1.setName("Thread1");
		thread1.start();
		
		Thread.sleep(1000);
		
		Thread thread2 = new Thread(){
			public void run() {
				method2();
			};
		};
		thread2.setName("Thread2");
		thread2.start();
	}
	
	public static void method1(){
		System.out.println(Thread.currentThread().getName() + "占用资源");
		synchronized(Test2.class){
			try {
				System.out.println("method1休眠5秒");
				Thread.sleep(5000);
				System.out.println("method1休眠完毕");
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	
	public static synchronized void method2(){
		//同步方法必须要有一个同步对象，他是Test2.class
		System.out.println(Thread.currentThread().getName() + "占用资源");
		try {
			System.out.println("method2休眠5秒");
			Thread.sleep(5000);
			System.out.println("method2休眠完毕");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2019-07-14 还是不太明白

春熙路迟迟侠

关于 JAVA 高级-反射机制-获取类对象的提问

步骤4 里最后一句 “ 那么如果在类方法前，加上修饰符 synchronized，同步对象是什么呢？” 是不是要加上 “静态” 两个字？变成 “ 那么如果在类静态方法前，加上修饰符 synchronized，同步对象是什么呢？”。不然我想不明白，比如两个同类的实例对象在两个线程同时工作(比如StringBuffer 类)，由于jvm只有一个StringBuffer类对象，两个线程的使用Stringbuffer实例对象时岂不是一直在冲突，如果是 static 方法的话由于它只会加载一次，所以冲突可以忽略。

3 个答案

hyjee
答案时间：2019-11-09

类方法不就是静态方法吗？

Q7_iu
答案时间：2019-09-14

回答的太好了，我都被他的提问绕进去了。。。哈哈哈

逆旅之人
答案时间：2019-08-05

类方法就是类的静态方法的一种简单说法，至于为什么这么说，因为它可以直接通过类名调用。要加深理解的话，可以和对象方法这个说法进行比较。至于类对象指的是一个类在jvm中加载后所形成的对象，每一个类都只有一个类对象，该类对象被所有的实例对象所共享。所以要注意类对象与类的实例对象的区别，这是两个不同的概念。如果你理解了我上面的几句话，应该不会再有你说的这些疑问了。

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2019-05-29 静态方法synchronized的锁是类对象

vi

关于 JAVA 高级-反射机制-获取类对象的提问

先执行线程t，让静态方法在线程之后执行，线程t获取类锁，释放cpu执行权5S，但仍旧持有锁，这段时间静态方法虽然获取到了执行权，但是没有执行打印语句，而是等到线程t执行完毕再执行，说明静态方法和线程t互斥，他们追求的是相同的锁对象。

public class Rflection2 {
	public static void main(String[] args) throws Exception{
		Thread t = new Thread() {
			public void run() {
				synchronized(Rflection2.class) {	
					System.out.println("线程run方法执行了,之后睡眠5s");
					try {
						Thread.sleep(5000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					System.out.println("线程睡眠结束，执行完成!");
				}
			}
		};
		t.start();
		Thread.sleep(200);
		run();
	}
	
	public synchronized static void run() {
		System.out.println("静态方法run调用了");
	}
}

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2018-08-06 zxc

木下

关于 JAVA 高级-反射机制-获取类对象的提问

z

package reflection;
 
public class TestReflection {
    public static void main(String[] args) throws InterruptedException {
        Thread t1= new Thread(){
            public void run(){
                //调用method1
                TestReflection.method1();
            }
        };
        t1.setName("第一个线程");
        t1.start();
         
        //保证第一个线程先调用method1
        Thread.sleep(1000);
         
        Thread t2= new Thread(){
            public void run(){
                //调用method2
                TestReflection.method2();
            }
        };
        t2.setName("第二个线程");
        t2.start();
    }
 
    public static void method1() {
 
        synchronized (TestReflection.class) {
            // 对于method1而言，同步对象是TestReflection.class，只有占用TestReflection.class才可以执行到这里
            System.out.println(Thread.currentThread().getName() + " 进入了method1方法");
            try {
                System.out.println("运行5秒");
                Thread.sleep(5000);
            } catch (InterruptedException e) {
 
                e.printStackTrace();
            }
        }
    }
 
    public static synchronized void method2() {
        // 对于mehotd2而言，必然有个同步对象，通过观察发现，当某个线程在method1中，占用了TestReflection.class之后
        // 就无法进入method2，推断出，method2的同步对象，就是TestReflection.class
        System.out.println(Thread.currentThread().getName() + " 进入了method2方法");
        try {
            System.out.println("运行5秒");
            Thread.sleep(5000);
        } catch (InterruptedException e) {
 
            e.printStackTrace();
        }
 
    }
}

3 个答案

bloodmarry
答案时间：2019-08-11

<alert>1</alert>

一位不愿透露姓名的lowB
答案时间：2019-01-02

上面的diao毛注释都不会改一下，把人家的类名改了同步对象也不会改一下

qq603924718
答案时间：2018-08-08

public class ConnTest { @Test public void test1() throws Exception{ Thread t1= new Thread(){ public void run(){ //调用method1 ConnTest.method1(); } }; t1.setName("第一个线程"); t1.start(); t1.join(); Thread t2= new Thread(){ public void run(){ //调用method2 ConnTest.method2(); } }; t2.setName("第二个线程"); t2.start(); } public static void method1() { synchronized (ConnTest.class) { // 对于method1而言，同步对象是TestReflection.class，只有占用TestReflection.class才可以执行到这里 System.out.println(Thread.currentThread().getName() + " 进入了method1方法"); try { System.out.println("1运行5秒"); Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("1111"); } } public static synchronized void method2() { // 对于mehotd2而言，必然有个同步对象，通过观察发现，当某个线程在method1中，占用了TestReflection.class之后 // 就无法进入method2，推断出，method2的同步对象，就是TestReflection.class System.out.println(Thread.currentThread().getName() + " 进入了method2方法"); try { System.out.println("2运行5秒"); Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } } }

代码超过 5行，点击查看

public class ConnTest {
 
 
    @Test
    public void test1() throws Exception{
        Thread t1= new Thread(){
            public void run(){
                //调用method1
                ConnTest.method1();
            }
        };
        t1.setName("第一个线程");
        t1.start();
 
 
        t1.join();
 
        Thread t2= new Thread(){
            public void run(){
                //调用method2
                ConnTest.method2();
            }
        };
        t2.setName("第二个线程");
        t2.start();
 
    }
 
    public static void method1() {
 
        synchronized (ConnTest.class) {
            // 对于method1而言，同步对象是TestReflection.class，只有占用TestReflection.class才可以执行到这里
            System.out.println(Thread.currentThread().getName() + " 进入了method1方法");
            try {
                System.out.println("1运行5秒");
                Thread.sleep(5000);
            } catch (InterruptedException e) {
 
                e.printStackTrace();
            }
            System.out.println("1111");
        }
    }
 
    public static synchronized void method2() {
        // 对于mehotd2而言，必然有个同步对象，通过观察发现，当某个线程在method1中，占用了TestReflection.class之后
        // 就无法进入method2，推断出，method2的同步对象，就是TestReflection.class
        System.out.println(Thread.currentThread().getName() + " 进入了method2方法");
        try {
            System.out.println("2运行5秒");
            Thread.sleep(5000);
        } catch (InterruptedException e) {
 
            e.printStackTrace();
        }
 
    }
 
 
 
}

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2018-07-30 练习题中，为什么加入t1.join();后，t2才输出

yoyo1314520

关于 JAVA 高级-反射机制-获取类对象的提问

不加t1.join()只输出第一个线程进入了method1方法 1运行5秒加了t1.join()输出：第一个线程进入了method1方法 1运行5秒 1111 第二个线程进入了method2方法 2运行5秒

public class ConnTest {


    @Test
    public void test1() throws Exception{
        Thread t1= new Thread(){
            public void run(){
                //调用method1
                ConnTest.method1();
            }
        };
        t1.setName("第一个线程");
        t1.start();


        t1.join();

        Thread t2= new Thread(){
            public void run(){
                //调用method2
                ConnTest.method2();
            }
        };
        t2.setName("第二个线程");
        t2.start();

    }

    public static void method1() {

        synchronized (ConnTest.class) {
            // 对于method1而言，同步对象是TestReflection.class，只有占用TestReflection.class才可以执行到这里
            System.out.println(Thread.currentThread().getName() + " 进入了method1方法");
            try {
                System.out.println("1运行5秒");
                Thread.sleep(5000);
            } catch (InterruptedException e) {

                e.printStackTrace();
            }
            System.out.println("1111");
        }
    }

    public static synchronized void method2() {
        // 对于mehotd2而言，必然有个同步对象，通过观察发现，当某个线程在method1中，占用了TestReflection.class之后
        // 就无法进入method2，推断出，method2的同步对象，就是TestReflection.class
        System.out.println(Thread.currentThread().getName() + " 进入了method2方法");
        try {
            System.out.println("2运行5秒");
            Thread.sleep(5000);
        } catch (InterruptedException e) {

            e.printStackTrace();
        }

    }



}

4 个答案

阿兔
答案时间：2019-01-10

我把你的代码修改后在没有t1.join()时运行了一遍，结果是：t1运行完后5s才运行t2，这是因为t1把t2要用的对象锁住了，逼迫t2必须等待t1执行完毕。但如果你把t2的锁取消掉，t1和t2的信息会立刻在控制台显示出来。但是如果有t1.join()，无论t2有没有锁，t2都会在t1运行完毕后执行,即5s后显示信息。你这种情况在特定条件看起来是一样的，就好比1+3和2+2都等于4，但是改变了条件，把+改成*，结果就是完全不一样的东西了。

代码超过 5行，点击查看

阿兔
答案时间：2019-01-10

回看这个页面http://inotgo.com/k/thread/thread-methods/354.html#nowhere 其中提到，main方法开始运行，就有一个看不见的主线程。join代表在主线程中加入t1。以你的代码为例来捋一捋加不加入join()的运行情况。不加入join：从main开始运行主线程，一直运行到t1.start()，启动新线程t1，同时主线程继续向下运行，启动新线程t2。主线程，t1，t2三个线程同时运行。加入join:从main开始运行主线程，一直运行到t1.start()，把t1线程加入到主线程中，主线程无法向下运行直到执行t1结束，启动新线程t2，主线程与t2线程同时运行。扩展一下，如果有三个线程t0，t1，t2。代码中只存在t1.join。那么线程运行情况如下： 1. t0与主线程同时运行。 2. t0与主线程（包含t1）同时运行。 3. t1执行完毕后，t0、主线程、t2同时运行。

名字不能重复多写几个字就不会重复了
答案时间：2018-11-18

是我太傻了吗？，用了t1.join()的意义在何处呢?

我会努力学JAVA的
答案时间：2018-09-14

你这个类没有主方法

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2018-05-05 请问基本类型如int, float有类对象吗

Duankang

关于 JAVA 高级-反射机制-获取类对象的提问

请问基本类型如int, float有类对象吗？试了一下int.class行得通。具体怎么解释？

3 个答案

探索
答案时间：2018-06-09

都是取Class的引用的，但是取得是不同的Class的引用。 Interger.TYPE == int.class 是基本类型int的Class的引用，int是基本类型在虚拟机运行时就已经加载了他的Class. Interger.class 是int的封装类Interger的引用。因此二者是不同的。

基本数据类型的 .class 都 ==  包装类型 .TYPE

探索
答案时间：2018-06-09

他们可以自动装拆箱就是自动进行转换

探索
答案时间：2018-06-09

int的类对象是Integer float的类对象为 Float char 为 Character 这个叫做包装类（封装类）

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2017-12-25 加包名与不加为什么类对象不一样

CHXYMJR

关于 JAVA 高级-反射机制-获取类对象的提问

Hero对象同在package Test 下，加包名类对象是一样的，不加包名类对象为什么不用啊？老师

package Test;

 
public class test {
 
    public static void main(String[] args) {
            String className = "Hero";
            try {
                Class pClass1=Class.forName(className);
                Class pClass2=Hero.class;
                Class pClass3=new Hero().getClass();
                System.out.println(pClass1);
                System.out.println(pClass2);
                System.out.println(pClass3);
            } catch (ClassNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
    }
}

初始化 copyright
class Hero
class Test.Hero
class Test.Hero

1 个答案

ewqddsad
答案时间：2018-01-10

Class.forName(className); 这个方法需要使用完整类名，也就是包名加上类的名称，其实类名就是包名加上类的名称才叫类名咱们平时使用的类名没有写包名是因为使用到import 进行了导包，可以理解成一种简写形式。

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2017-12-09 练习的最后一个问题

美好的人生

关于 JAVA 高级-反射机制-获取类对象的提问

这两种方法写synchronized的地方不一样，他们表达的意思一样？只是不同的写法？

 public static void method1() {
 
        synchronized (TestReflection.class) {
            // 对于method1而言，同步对象是TestReflection.class，只有占用TestReflection.class才可以执行到这里
            System.out.println(Thread.currentThread().getName() + " 进入了method1方法");
            try {
                System.out.println("运行5秒");
                Thread.sleep(5000);
            } catch (InterruptedException e) {
 
                e.printStackTrace();
            }
        }
    }
 
    public static synchronized void method2() {
        // 对于mehotd2而言，必然有个同步对象，通过观察发现，当某个线程在method1中，占用了TestReflection.class之后
        // 就无法进入method2，推断出，method2的同步对象，就是TestReflection.class
        System.out.println(Thread.currentThread().getName() + " 进入了method2方法");
        try {
            System.out.println("运行5秒");
            Thread.sleep(5000);
        } catch (InterruptedException e) {
 
            e.printStackTrace();
        }
 
    }

3 个答案

Hum0r0
答案时间：2019-09-15

不是的，在类方法前面加synchronized锁定的是这个类的所有对象，因为类方法是属于这个类的方法，而在对象方法前加synchronized锁定的是该类的当前实例。

JAVA界的盖伦
答案时间：2019-03-31

一样的

SmallCxl
答案时间：2017-12-29

第一种方法显示地指出同步对象是是类对象，第二种方法同步类的静态方法，实验发现同步的对象也是类对象。这只是解答“在静态方法上加synchronized，同步对象是什么？” 这个问题而已，显然，答案是类对象。

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2017-11-07 使用.class不会初始化Class对象

2017-08-28 如何获取同一个包的类对象

parton

关于 JAVA 高级-反射机制-获取类对象的提问

老师您好，我在做反射练习的时候没有办法取到同一个包下面的类对象。但是我要是把想获取的类对象放到另一个包之后，并且填上正确的类名就可以获取类对象。不知道是为什么？请问可以获取同一个包的类对象么？

package reflection;

public class Reflection {
	public static void main(String[] args) {
		String className = "Hero";
		try {
			Class pClass1 = Class.forName(className);
			
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}
}

java.lang.ClassNotFoundException: Hero
	at java.net.URLClassLoader.findClass(Unknown Source)
	at java.lang.ClassLoader.loadClass(Unknown Source)
	at sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source)
	at java.lang.ClassLoader.loadClass(Unknown Source)
	at java.lang.Class.forName0(Native Method)
	at java.lang.Class.forName(Unknown Source)
	at reflection.Reflection.main(Reflection.java:7)

4 个答案

我会努力学JAVA的
答案时间：2018-09-14

这个在jdbc中就有啊，连接数据库中用到了class.forName这个方法

mdls
答案时间：2017-12-23

一个类的位置是由包名+类名确定的，你只写类名它肯定找不到对应的类

我爱代码
答案时间：2017-10-30

谢谢站长，终于懂了，为啥子要用character.Hero

how2j
答案时间：2017-08-30

需要给出类的full name哦，得写成： "reflection.Hero"

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2017-07-04 dwre

2017-07-04 dgftryh

2016-06-30 .getName() 改成,name吧