Core Java(十二)

最新推荐文章于 2023-05-06 22:15:33 发布
最新推荐文章于 2023-05-06 22:15:33 发布
阅读量869 收藏 1
点赞数
分类专栏： JAVA(J2SE) 文章标签： java class string constructor import integer
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuchen2008/article/details/1472660
版权
 
反射：
什么是反射？有什么用？
先了解一些基本的概念：运行时，编译时，编译型，解释型，类加载器，动态加载类
什么是编译？将原程序翻译成计算机语言，就是二进制代码，在java中是将.java文件也就是源程序翻译成.class的字节码
什么是编译时？将原程序翻译成计算机语言的过程中，将.java翻译为.class文件的过程
什么是运行时？就是在启动这个程序的时候，在java中是,类加载器加载.class文件，并交给jvm处理
什么是编译型语言？将原程序一次性全部转换为二进制代码，然后执行程序
什么是解释型语言？转换一句，执行一句，java是既编译又解释的语言
编译型语言和解释型语言的区别：编译型语言效率高，依赖于编译器，但是跨平台差，解释型的效率低，依赖于解释器，但跨平台强
什么是类加载器？类加载器就是JVM中的类装载器，作用就是将编译好的.class字节码运到检查器进行安全检查的，检查通过后开始解释执行
什么是运行时动态加载类？
反射就是可以将一个程序（类）在运行的时候获得该程序（类）的信息的机制，也就是获得在编译期不可能获得的类的信息，因为这些信息是保存在Class对象中的，而这个Class对象是在程序运行时动态加载的
它就是可以在程序运行的时候动态装载类，查看类的信息，生成对象，或操作生成对象。类在运行的时候，可以得到该类的信息，并且可以动态的修改这些信息，自己能看到自己，跟照镜子一样，class对象是在运行的时候产生的，通过class对象操作类的信息是在运行时进行的，当运行程序的时候，类加载器会加载真正需要的类，什么是真正需要的呢？就是该类真正起作用，如：有该类的对象实例，或该类调用了静态方法属性等
反射的作用第一，远程方法调用，第二，通过容器得到组件的对象
 
如何实现反射呢？
得到Class对象
三种方式得到Class对象：
1．调用对象的getClass方法，返回该对象的Class对象
2．Class.forName(“类的名字”);有个受查异常
3．Class c=类名.class
/**
 * 知识点：
 * Class类
 * 知道一个类的对象的名字，就能得到该对象所在类的信息
 * 对象.getClass();   getClass()方法是在Object类中定义的
 * 程序目标：
 * 创建一个对象，得到它的类的信息，如：类名，父类是谁等等
 */
package MY.module12.Class.t1;
 
public class ClassDemo {
 
       /**
        * @param args
        */
       public static void main(String[] args) {
              // TODO Auto-generated method stub
              String s="hello world";
              Class c=s.getClass();
              System.out.println("类的名字为："+c.getName());
              System.out.println("是否为接口类型："+c.isInterface());
              System.out.println("是否为数组类型："+c.isArray());
              System.out.println("是否为基本类型："+c.isPrimitive());
              System.out.println("父类的名字为："+c.getSuperclass().getName());
       }
 
}
/**
 * 知识点：
 * 类被加载的情况
 * 当真正使用一个类的时候，该类才会被加载，也就是实例一个对象的时候
 * 程序目标：
 * 测试什么时候类被加载
 */
package MY.module12.Class.t2;
 
public class LodaClassTest {
 
       /**
        * @param args
        */
       public static void main(String[] args) {
              // TODO Auto-generated method stub
              TestClass test=null;
              System.out.println("声明个TestClass类的引用");
              test=new TestClass();
              System.out.println("生成TestClass实例");
       }
 
}
package MY.module12.Class.t2;
 
public class TestClass {
       static{
              System.out.println("类被载入");
       }
}
/**
 * 知识点：
 * 得到class对象的三种方式
 * Java文件说明：
 * Student.java
 * TestClass.java
 * 程序目标：
 * 使用三种方式得到class对象，并且通过class对象得到一个实例
 */
package MY.module12.reflection.Class.t3;
 
public class TestClass {
 
       /**
        * @param args
        */
       public static void main(String[] args) {
              // TODO Auto-generated method stub
              Student stu1=new Student();
              //得到class对象的三种方式
              //第一种
              Class c1=stu1.getClass();
             
              //第二种
              try {
                     Class c2=Class.forName("MY.module12.reflection.Class.t3.Student");
              } catch (ClassNotFoundException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
              }
             
              //第三种
              Class c3=Student.class;
             
              //使用class对象能做什么呢？
              //可以得到该类的一个实例
              try {
                     Student stu2=(Student)c3.newInstance();
                     System.out.println(stu2);
              } catch (InstantiationException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
              } catch (IllegalAccessException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
              }
       }
 
}
package MY.module12.reflection.Class.t3;
 
public class Student {
       private String name;
       private int age;
       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() {
              // TODO Auto-generated method stub
              StringBuffer sb=new StringBuffer();
              sb.append(name+":");
              sb.append(age);
              return sb.toString();
       }
      
}
 
分析类的能力：如何分解它
设置属性：
/**
 * 知识点：
 * 设置属性
 * 程序目标：
 * 知道一个类的名字和类中的属性，去设置并得到这个属性的值
 */
package MY.module12.reflection.Field;
import java.lang.reflect.*;
public class TestField {
      
       /**
        * @param args
        */
       public static void main(String[] args) {
              // TODO Auto-generated method stub
              try {
                     Class c=Class.forName("MY.module12.reflection.Field.A");
                     A a1=(A)c.newInstance();
                     Field f=c.getField("i");
                     int i=f.getInt(a1);
                     System.out.println(i);
                     f.setInt(a1,20);
                     int j=f.getInt(a1);
                     System.out.println(j);
              } catch (ClassNotFoundException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
              } catch (InstantiationException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
              } catch (IllegalAccessException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
              } catch (SecurityException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
              } catch (NoSuchFieldException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
              }
       }
 
}
class A{
       public int i=1;
}
 
如果我们不知道类中的属性名和数量，并且都是私有的，应该如何设置属性呢？
/**
 * 知识点：
 *getDeclaredFields(),getDeclaredField(String s),AccessibleObject.setAccessible(f,true);
 * 程序目标：
 * 只知道类的名字和属性的类型，设置和得到类中私有属性的值
 */
package MY.module12.reflection.Field;
import java.lang.reflect.*;
public class TestField2 {
      
       public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
              // TODO Auto-generated method stub
                     Class c=Class.forName("MY.module12.reflection.Field.B");
                     B b=(B)c.newInstance();
                     Field[] f=c.getDeclaredFields();
                     AccessibleObject.setAccessible(f,true);
                     int value=f[0].getInt(b);
                     System.out.println(value);
                     f[0].setInt(b,10);
                     int value2=f[0].getInt(b);
                     System.out.println(value2);
       }
 
}
class B{
       private int i=1;
}
 
设置方法构造器（带参和不带参的）：
/**
 * 知识点：
 * Method
 * 程序目标：
 * 知道类名，方法的名字和参数类型，调用该类的方法
 */
package MY.module12.reflection.Method;
import java.lang.reflect.*;
public class TestMethodInvoke {
      
       /**
        * @param args
        * @throws ClassNotFoundException
        */
       public static void main(String[] args) throws ClassNotFoundException {
              // TODO Auto-generated method stub
              Class c=Class.forName("MY.module12.reflection.Method.A");
              try {
                     A a=(A)c.newInstance();
                     Method m=c.getMethod("f1",new Class[]{int.class});
                     m.invoke(a,new Object[]{new Integer(10)});
                     m=c.getMethod("f2",new Class[]{int.class});
                     m.invoke(null,new Object[]{new Integer(20)});
              } catch (InstantiationException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
              } catch (IllegalAccessException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
              } catch (SecurityException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
              } catch (NoSuchMethodException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
              } catch (IllegalArgumentException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
              } catch (InvocationTargetException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
              }
       }
 
}
class A{
       public void f1(int i){
              System.out.println("f1:"+i);
       }
      
       public static void f2(int i){
              System.out.println("f2:"+i);
       }
}
 
/**
 * 知识点：
 * 实例对象（带参和不带参）Constructor类
 * 程序目标：
 * 知道一个类的名字和类中构造器的参数，实例化带参和不带参数的对象
 */
package MY.module12.reflection.constructor;
import java.lang.reflect.*;
public class TestConstructor {
      
       public static void main(String[] args) throws ClassNotFoundException, SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException {
              // TODO Auto-generated method stub
              Class c=Class.forName("MY.module12.reflection.constructor.B");
              B b1=(B)c.newInstance();//不带参数
              //带参数
              Class[] can=new Class[]{String.class,int.class};
              Constructor constructor=c.getConstructor(can);
              B b2=(B)constructor.newInstance(new Object[]{new String("yuchen"),new Integer(23)});
       }
 
}
class B{
       public B(){
              System.out.println("b.....");
       }
      
       public B(String s,int i){
              System.out.println(s+":"+i);
       }
}
/**
 * 知识点：
 * getName,Modifier类，getModifiers(),getType(),getDeclaredFields()
 * getDeclaredMethod(),getDeclaredConstructors(),getParameterTypes()
 * Java文件说明：
 * Son.java
 * Father.java
 * printClassinfo.java
 * 程序目标：
 * 知道一个类的名字
 * 1.显示该类的名字和父类的名字
 * 2.打印该类中的所有属性，方法，构造器，其中方法结构：
 * 修饰符，返回类型，名字，参数类型
 */
package MY.module12.reflection.printClassinfo;
import java.lang.reflect.*;
public class printClassinfo {
 
       /**
        * @param args
        */
       public static void main(String[] args) {
              // TODO Auto-generated method stub
              Class c=Son.class;
              Class superC=c.getSuperclass();
              if(superC!=null&&superC!=Object.class){
                     System.out.println(c.getName()+"是"+superC.getName()+"的子类");
              }else{
                     System.out.println(c.getName());
              }
              System.out.println("{");
              printField(c);
              System.out.println();
              printConstructor(c);
              System.out.println();
              printMethod(c);
              System.out.println("}");
       }
       public static void printField(Class c){
             Field[] field=c.getDeclaredFields();
              for(int i=0;i<field.length;i++){
                     System.out.print(Modifier.toString(field[i].getModifiers())+" ");
                     System.out.print(field[i].getType().getName()+" "+field[i].getName());
              }
       }
       public static void printMethod(Class c){
              Method[] m=c.getDeclaredMethods();
              for(int i=0;i<m.length;i++){
                     System.out.print(Modifier.toString(m[i].getModifiers())+" ");
                     Class returns=m[i].getReturnType();
                     System.out.print(returns.getName()+" "+m[i].getName()+"(");
                     Class[] type=m[i].getParameterTypes();
                     for(int j=0;j<type.length;j++){
                            if(j>0){
                                   System.out.print(",");
                            }
                            System.out.print(type[j].getName());
                     }
                     System.out.println(")");
              }
             
       }
       public static void printConstructor(Class c){
              Constructor[] cs=c.getDeclaredConstructors();
              for(int i=0;i<cs.length;i++){
                     System.out.print(Modifier.toString(cs[i].getModifiers())+" ");
                     System.out.print(cs[i].getName()+"(");
                     Class[] Type=cs[i].getParameterTypes();
                     for(int j=0;j<Type.length;j++){
                            if(j>0)
                                   System.out.print(",");
                                   System.out.print(Type[j].getName());
                                   }
                     System.out.println(");");
                     }
              }
       }
package MY.module12.reflection.printClassinfo;
 
public class Son extends Father{
       private String name;
 
       public Son() {
              // TODO Auto-generated constructor stub
       }
 
       public Son(String name,int i) {
              // TODO Auto-generated constructor stub
              this.name = name;
       }
      
       public void sonf(){
             
       }
      
       public void sonf2(int i,String name){
             
       }
}
package MY.module12.reflection.printClassinfo;
 
public class Father {
       public Father(){
             
       }
       public Father(String name){
             
       }
      
       public void f1(){
              System.out.println("Father's f1()");
       }
}
/**
 *知识点：
 *反射，读配置文件的工具包类
 *java文件说明：
 *Greeting.java:接口，有个抽象方法
 *GreetingChineslmpl.java:实现接口方法，打印中文
 *GreetingEnglishlmpl.java:实现接口，打印英文
 *GreetingFactory.java：工厂方法：生产Greeting类型的对象
 *ConfigUtil.java:读取配置文件，得到文件中的类信息（类名）
 *Test.java:输入配置文件中的名字，得到Greeting对象，调用打印方法
 *程序目标：
 *用户传个参数
 *通过工厂方法得到对象，工厂方法通过配置文件类得到类名，然后工厂
 *方法通过反射得到对象，返回给用户
 */
package MY.module12.exec.reflection.greetings;
 
import java.io.IOException;
 
public class Test {
       public static void test(String name){
              Greeting g=null;
              try {
                     g = GreetingFactory.getGreeting(name);
              } catch (IOException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
              }
              g.sayHello();
       }
       /**
        * @param args
        */
       public static void main(String[] args) {
              // TODO Auto-generated method stub
              test("classname");
       }
 
}
package MY.module12.exec.reflection.greetings;
import java.io.IOException;
import java.util.*;
public class ConfigUtil {
       public static String getProperty(String name) throws IOException{
              String className=null;
              Properties p=new Properties();
              p.load(ConfigUtil.class.getClassLoader().getResourceAsStream("MY/module12/exec/reflection/greetings/config.properties"));
              className=p.getProperty(name);
              return className;
       }
}
package MY.module12.exec.reflection.greetings;
 
public interface Greeting {
       public void sayHello();
}
package MY.module12.exec.reflection.greetings;
 
public class GreetingChineselmpl implements Greeting{
 
       public void sayHello() {
              // TODO Auto-generated method stub
              System.out.println("你好");
       }
      
}
package MY.module12.exec.reflection.greetings;
 
public class GreetingEnglishlmpl implements Greeting{
 
       public void sayHello() {
              // TODO Auto-generated method stub
              System.out.println("hello");
       }
      
}
package MY.module12.exec.reflection.greetings;
 
import java.io.IOException;
 
public class GreetingFactory {
       public static Greeting getGreeting(String name) throws IOException{
              Greeting rst=null;
              String className=ConfigUtil.getProperty(name);
              try {
                     Class c=Class.forName(className);
                     rst=(Greeting)c.newInstance();
              } catch (ClassNotFoundException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
              } catch (InstantiationException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
              } catch (IllegalAccessException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
              }
              return rst;
       }
}
config.properties :classname=MY.module12.exec.reflection.greetings.GreetingChineselmpl
 
yuchen2008
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关于javacore和dump文件
LeesinDong的个人博客
01-04 1万+
Dump 就是对程序运行时内存上的信息进行转储, 让我们可以查看程序当时的运行情况. Dump 对于调优和排错是非常有用的工具. Heap Dump Java 运行时对象分配在堆内存上, Heap dump 就是对堆内存进行转储. 生成 jmap 通过命令jmap -dump:live,format=b,file=***.hprof pid eg:jmap -dump:live,format=b,...
IBM JDK生成Javacore的方法
架构师学习成长之路
06-30 3563
    根据IBM JDK的文档，有以下的方法可以选择生成Javacore:1. JVM执行异常时，自动生成Javacore1.1 发生了引起JVM停止运行的本地错误时，会自动产生Javacore文件1.2 JVM内存不足时，会自动产生Javacore文件2. 触发JVM生成JDK2.1 从命令行中发出kill -3 &lt;pid&gt;指令，生成Javacore2.2 在应用中调用com.ib...
java core 分析_JavaCore文件分析 | 學步園
weixin_32491255的博客
02-23 3802
產生時間Java程序運行時，有時會產生JavaCore及HeapDump文件，它一般發生於Java程序遇到致命問題的情況下。有時致命問題發生後，Java應用不會死掉，還能繼續運行；但有時致命問題發生，Java進程會死掉；為了能夠保留Java應用發生致命錯誤前的運行狀態，JVM在死掉前產生兩個文件，分別為JavaCore及HeapDump文件。有何區別JavaCore是關於CPU的，而HeapDum...
java core 分析_jca工具分析was的javacore实例解析
weixin_39968722的博客
02-12 2687
一朋友打电话求助，问怎样简单方便的分析WAS的JAVACORE文件。我给他做了个实例解析，下面是一个过程记录。一、工具下载可从IBM官网下载JCA工具，专门用来分析JAVACORE文件的工具。使用JCA工具需要JAVA环境，再下载一个JDK。由于我们使用的JCA是3.9.6版，所以下载一个JDK1.6版的就行。二、启动JCA工具安装完JDK1.6后，配置JAVA环境。JAVA环境的配置简单说一下：...
JAVA核心技术卷1 corejava.zip 下载地址
滕青山博客
01-31 4491
JAVA核心技术卷1 第11版： 官方下载地址：http://horstmann.com/corejava/corejava.zip 百度云链接:https://pan.baidu.com/s/13yOv0iyBWonv21Oytvrnhw提取码: fqwe
java core 生成路径_core文件生成和路径设置
weixin_39542514的博客
02-27 2630
在程序崩溃时，内核会生成一个core文件,即程序最后崩溃时的内存映像，和程序调试信息。 之后可以通过gdb,打开core文件察看程序崩溃时的堆栈信息，可以找出程序出错的代码所在文件和函数。1.core文件的生成开关和大小限制 1)使用ulimit -a命令，可以察看core文件的生成开关和大小限制所有信息 2)使用ulimit -c命令可查看core文件的生成开关。若结果为0，则表示关闭了此功...
JVisualVM 手动生成 Java Core Dump
相距2289公里的专栏
12-10 2151
最近在研究 Java Core Dump 查看及使用问题，这里我采了JDK自带工具jvisualvm ，这个工具可协助生成 Java Core Dump 文件 1, Java Core Dump 文件是什么 Java Core Dump 文件呢，是针对 JVM 虚拟机发生致命问题或者 JVM 中运行的程序造成致命问题时，所产生的记录文件，通常会存在2个文件 1.1，Java Cor...
盼了一年的Core Java最新版卷Ⅱ，终于上市了（文末送书）
学Java，找哪吒
05-06 4423
新版延续之前版本的优良传统，用数百个实际的工程案例，全面系统地讲解了Java语言的核心概念、语法、 重要特性、 开发方法。Java诞生28年来，这本享誉全球的 Java 经典著作《Core Java》一路伴随着 Java 的成长，得到了百万 Java 开发者的青睐，成为一本畅销不衰的Java经典图书，影响了几代技术人。目前已经700+订阅，CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
linux如何生成javacore文件,如何产生javacore和heapdump文件》
weixin_42514752的博客
04-28 2272
1.windows&Linux：修改运行脚本的javaw到java，并且添加参数-XX:+HeapDumpOnCtrlBreak。运行程序后，按ctrl+break，就可以得到heapdump文件。-Djava.awt.headless=true -XX:+HeapDumpOnOutOfMemoryError-XX:HeapDumpPath=c:\heapdump2.solari...
JAVACORE与HEAPDUMP生成大法
热门推荐
Z.Virgil的博客
11-01 2万+
目录 前言 JAVACORE篇： Windows平台： ORACLE JDK：HOTSPOT IBM JDK：V9 LINUX平台：　　　　　　　　　　　　　　　　　　 HEAPDUMP篇： Windows平台： ORACLE JDK：HOTSPOT IBM JDK：V9 LINUX平台: 前言 在项目上我们经常要生成javacore和heapdump来进行分析。这里总...
corejava12示例代码
12-25
corejava12示例代码
CoreJava全套详细笔记资料.pdf
03-11
参考使用，欢迎下载
Core Java 学习笔记
06-14
《Core Java》学习笔记。 我把自己的笔记都以注释的形式写在代码里面了，这样方便理解。 尽管有些部分被标记为“已完成”，但实际上以后说不定我还会折返回来进行修改或者添加一些注释。 当然如果你有什么不理解...
corejava8.rar
最新发布
12-25
java corejava8
CoreJava
03-26
CoreJava
JAVA编程基础：第九章 swing类
09-13 3042
  如何创建更好看的界面1.导入swing包，里面有更好看的组件2.创建各个组件的实例，然后添加到面板import java.awt.*;import javax.swing.*; //swing包中的组件是从awt包扩展而来的，这些组件更好看 知识点1．Java 基本类库 (JFC)JFC 通过添加一组 GUI 类库扩展了原始 AWTJFC提供附加的可视化
JAVA编程基础：第八章 图形编程
09-10 2798
如何绘制图形1．需要编写扩展 JPanel 类的新类。2．在Jpanel类或子类中覆盖父类的paintComponent() 方法import java.awt      //使用awt包 此包支持绘制图形的方法import javax.swing   //使用swing包此包中有Jframe Jpanel等组件class jp extends Jpanel{   pu
Core Java(十)
12-21 1904
知识点：IO什么是IO？输入输出input output,这是指以程序为中心，就是站在程序的角度说的，程序其实是JVM,例如：写程序将一些信息存储到文件中，这叫输出（写入）；如果程序从文件得到信息，就叫输入（读取） 文件：什么是文件？指计算机中的文件和目录文件的作用就是存取查看文件和java中的File类：File相当于指向文件的指针，它本身并不是文件，如果我们想通过程序来
Core Java(七)
12-05 1611
 第六讲异常知识点1 什么是异常jvm将java程序中非正常情况打包成一个对象，这个对象就叫异常异常的分类：错误和异常什么是错误？指的是系统错误，程序无法恢复，比如说找不类，内存益出等异常：程序中需要被捕获并处理的错误捕获并处理异常是为了让程序能够正常运行受查异常，非受查异常，运行时异常受查异常就是编译时候进行检查的异常非受查异常是编译的时候不进行检查，
core java for the impatient pdf
08-17
《Java核心技术卷1：基础知识——适用于急于实践的读者》是由Cay S. Horstmann和Gary Cornell合著的一本畅销书籍。这本书主要面向那些希望快速入门Java编程语言的读者。 《Java核心技术卷1：基础知识——适用于急于...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值