Class类

万事万物皆对象，但是静态的成员和基本数据类型不是面向对象的，基本数据类型都有包装类。
类也是对象，是java.lang.Class的实例对象

public class ClassDemo1 {

    public static void main(String[] args) {
        //Foo的实例对象表示
        Foo foo1=new Foo();
        //Foo本身也是一个实例对象，Class类的实例对象
        //任何一个类都是Class类的实例对象，这个实例对象有三种表示方式

        //第一种表示方式--实际在告诉我们每一个类都有一个隐含的静态成员变量
        Class c1=Foo.class;

        //第二种表示方式，已知该类的实例对象通过getClass方法
        Class c2=foo1.getClass();

        /*官网c1,c2表示了Foo类的类类型（class type）
         * 万事万物皆对象
         * 类也是一个对象
         * 这个对象我们称为该类的类类型
         * */

        //不管c1 还是 c2 都代表了Foo类的类类型，一个类只可能是Class类的一个实例对象
        System.out.println(c1==c2);

        //第三种表示方式
        Class c3=null;
        try {
            c3=Class.forName("com.imooc.reflect.Foo");
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(c2==c3);
        //可以通过该类的类类型创建该类的实例对象-->通过c1 or c2 or c3创建Foo的实例对象
        try {
            Foo foo=(Foo) c1.newInstance();//前提是要有无参数的构造方法
            foo.print();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}
class Foo{
    void print(){
        System.out.println("foo");
    }

}

Class.forName(“类的全称”);
不仅代表了类的类类型，还代表了动态加载类
编译时刻加载类是静态加载类，运行时刻加载类是动态加载类

用记事本编写office类，

class  Office
{
    public static void main(String[] args) 
    {
        //new 创建对象 是静态加载类，在编译时就加载所有可能用到的类
        if("word".equals(args[0]))
        {
            Word w =new Word();
            w.start();
        }
        if ("Excel".equals(arg[0]))
        {
            Excel e= new Excel();
            e.start();
        }
    }
}

这个类显然是不能通过编译的，会报ClassNotFoundException异常，找不到Word类，Excel类，start方法，但是Word类和Excel类一定会用到吗，不一定，即使我们写了Word类，但只要Excel类出问题，Word类也是不能用的，new 创建对象 是静态加载类，在编译时就加载所有可能用到的类，在实际应用当中，我们希望Word存在，Word就能用，用Excel的时候再说Excel有问题不能用，如果将来有一百个功能，只要有一个有问题，其他九十九个都用不了，这是编译时加载导致的，所以我们希望用哪个就加载哪个，我们再编写一个动态加载类

先定义一个借口，保存为OfficeAble.java

interface OfficeAble
{
    public void start();
}

然后让Word类实现该接口，保存为Woid.java

class Word implements OfficeAble
{
    public void sart()
    {
        System.out.println("word....start")
    }
}

然后定义动态加载类

class  OfficeBetter
{
    public static void main(String[] args) 
    {
        try
        {
            //动态加载类，在运行时刻加载
            Class.forName(args[0]);
            //通过类类型创建该类对象
            OfficeAble oa=(OfficeAble)c.newInstance();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }


    }
}

在命令行中运行Java代码

此时Word跟Excel就没什么关系了，当我们使用Excel时Excel才会报错

如果我们想用Excel，只需要写一个Excel类实现OfficeAble接口就可以了

class Excel implements OfficeAble
{
    public void start()
    {
        System.out.println("excel....start");
    }
}

我们运行Excel.java

此时OfficeBetter并不需要重新编译，直接运行即可，也就是说如果以后OfficeBetter需要实现其他功能，并不需要修改OfficeBetter，只需动态添加新的功能，相当于软件的在线升级

Java中一切皆是对象！这句话没错，因为八种基本类型都有对应的包装类（int的包装类是Integer），包装类自然就是对象了。 基本类型一直都是Java语言的一部分，这主要是基于程序性能的考量，基本类型定义定义的变量是存放在栈中，比如int i = 5；而Integer j = new Integer（10）；j则只是一个对象的引用，存放在栈中，而实际的数值10则是放在堆里，堆的读写速度远不及栈了。再有就是基本类型定义的变量创建和销毁很快，而类定义的变量还需要JVM去销毁。
在你的程序中如果某些数据可能会返回空值，那么是要用包装类的，比如
当结果为空时，转换为int会发生异常，而转换为Integer则不会，因为对象可以为null。一般建议用包装类，虽然会牺牲一些转换效率，但可以避免持久化数据时产生的一些异常。