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");

   Class.forName("Line");   //获取到类的实例

  if(args.length != 1)

   return;

   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();   //返回对象所有的方法

    System.out.println(me[i]);       //调用默认的构造函数

   Class[] params = cons[0].getParameterTypes();   //返回构造方法的参数信息，表示参数的类型

   Object[] paramValues = new Object[params.length];  //构造Object数组，为newInstance使用

   {

    if(params[i].isPrimitive())      //isPrimitive判断是否是基本的数据类型

    {

     paramValues[i] = new Integer(i+3);     //调用基本数据类型的封装类,给构造方法传参

    }

   }

   Object o = cons[0].newInstance(paramValues);  //newInstance需要Object数组为参数，返回一个没有默认构造函数的类

   Method me = c.getDeclaredMethod();   //返回所有的方法

   me[0].invoke(o, null);       //调用指定的方法，只有一个方法，因此me[0]就是output方法。output没有参数，设置为null

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

  System.out.println("line");

每一个java程序都有一个单一的Runtime类，通过getRuntime()获取Runtime实例。

它提供了应用程序和环境的接口，可以反映出内存等信息

class RuntimeTest

  Runtime rt = Runtime.getRuntime();

  System.out.println(rt.freeMemory);

  System.out.println(rt.totalMemory);

   rt.exec("notepad");     //exec可以执行外部子程序，打开记事本

   rt.exec("javac hello.java");   //编译一个文件

在我们进行程序设计时，逐渐形成了一些典型问题和问题的解决方案，这就是软件模式。

每一个模式描述了一个在我们程序设计中经常发生的问题，以及该问题的解决方案。

当我们碰到模式所描述的问题，就可以直接用相应的解决方法去解决这个问题，这就是设计模式。

单例（Singleton）模式

   （1）一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类。

   （2）单例类的一个最重要的特点是类的构造方法是私有的，从而避免了外部利用构造方法直接创建多个实例。