java之路，Class类

封装类 int -> Integer   float -> Float   long -> Long   double -> Double
       boolean -> Boolean    char -> Char    byte -> Byte 封装类是只读的

class Test
{
 public static void main (String[] args)
 {
  int i = 3;
  Integer in = new Integer(1);
  
  int j = in.intValue();               //返回Integer所表示的整形值
  String str = in.toString();          //int 转为 string
  String str = "123";
  System.out.println(Integer.valueOf(str));  //string转为int
  
 }
}

Class类，在java中每一个class都有一个对应的Class对象，用于表示这个类的类型信息
获取一个Class实例的方式：
1、利用对象调用getClass（）方法
2、使用Class类的静态方法forName（），用类的名字获取一个Class实例
3、运用.class获取Class实例，对于基本数据类型的封装类，还可以通过.TYPE来获取对应基本数据类型的Class实例

在运行期间，如果要产生某个类的对象，java虚拟机会检查该类型的Class对象是否已经加载，
如果没有加载，jvm会根据类名找到.class问价并加载。一旦某个类型的Class对象已经被加载
到内存，就可以用它来产生该类型的所有对象

newInstance调用类中缺省的构造方法（就是不带参数的构造方法），可以在不知类名的情况下创建一个实例

class ClassTest
{
 public static void main(String[] args)
 {
  Point pt = new Point();
  Class c1 = pt.getClass();
  try
  {
   Class c2 = pt.forName(Point);    //forName方法会产生异常
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
  Class c3 = Point.class();
  Class c4 = int.class();
  Class c5 = Integer.TYPE;
  Class c6 = Integer.class();
  System.out.println(c1.getName());
  System.out.println(c2.getName());
  System.out.println(c3.getName());
  System.out.println(c4.getName());
  System.out.println(c5.getName());
  System.out.println(c6.getName());
  
  
  System.out.println("before point");
  new Point();          //创建实例，打印static里的语句
  System.out.println("after point");
  try
  {
   Class.forName("Line");   //获取到类的实例
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
  
  
  if(args.length != 1)
   return;
  try
  {
   Class c = Class.forName(args[0]);
  // Point pt = (Point)c.newInstance();   //从命令行传参 java ClassTest Point
  // pt.output();
  
  
  //反射API，返回对象的信息，
   Constructor[] cons = c.getDeclaredConstructors();   //返回所有的构造方法，需要导入java.lang.reflect包
   for(int i=0; i     System.out.println(cons[i]);
    
   Method me = c.getDeclaredMethod();   //返回对象所有的方法
   for(int i=0; i     System.out.println(me[i]);       //调用默认的构造函数
    
   Class[] params = cons[0].getParameterTypes();   //返回构造方法的参数信息，表示参数的类型
   Object[] paramValues = new Object[params.length];  //构造Object数组，为newInstance使用
   for(int i=0; i    {
    if(params[i].isPrimitive())      //isPrimitive判断是否是基本的数据类型
    {
     paramValues[i] = new Integer(i+3);     //调用基本数据类型的封装类,给构造方法传参
    }
    System.out.println(cons[i]);
   }
   Object o = cons[0].newInstance(paramValues);  //newInstance需要Object数组为参数，返回一个没有默认构造函数的类
   Method me = c.getDeclaredMethod();   //返回所有的方法
   me[0].invoke(o, null);       //调用指定的方法，只有一个方法，因此me[0]就是output方法。output没有参数，设置为null
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
  
 }
}
class Point
(
 int x,y;
 static
 {
  System.out.println("segment");
 }
 void output()
 {
  System.out.println("x="x "", + "," + "y=" + y);
 }
 void Point(int x, int y)
 {
  this.x = x;
  this.y = y;
 }
)

class Line
{
 static
 {
  System.out.println("line");
 }
}

 

每一个java程序都有一个单一的Runtime类，通过getRuntime()获取Runtime实例。
它提供了应用程序和环境的接口，可以反映出内存等信息
class RuntimeTest
{
 public static void main(String[] args)
 {
  Runtime rt = Runtime.getRuntime();
  System.out.println(rt.freeMemory);
  System.out.println(rt.totalMemory);
  
  try
  {
   rt.exec("notepad");     //exec可以执行外部子程序，打开记事本
   rt.exec("javac hello.java");   //编译一个文件
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
 }
}
在我们进行程序设计时，逐渐形成了一些典型问题和问题的解决方案，这就是软件模式。
每一个模式描述了一个在我们程序设计中经常发生的问题，以及该问题的解决方案。
当我们碰到模式所描述的问题，就可以直接用相应的解决方法去解决这个问题，这就是设计模式。
单例（Singleton）模式
   （1）一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类。
   （2）单例类的一个最重要的特点是类的构造方法是私有的，从而避免了外部利用构造方法直接创建多个实例。