class  CarDemo
{
        public static void main(String[] args)
        {
                Car c=new Car();
                c.num=5;
                Car c1=c;
                c1.color="green";
                c.run();
        }
}
class Car
{
        //描述颜色
        String color="red";
        //描述轮胎数
        int num=4;
        //描述行为
        public void run()       
                {
                        System.out.println(num+"::"+color);
       
                }
       
}
class  CarDemo
{
        public static void main(String[] args)
        {
                Car c=new Car();
                c.num=5;
                Car c1=new Car();
                c1=c;
                c1.color="green";
                c.run();
        }
}
class Car
{
        //描述颜色
        String color="red";
        //描述轮胎数
        int num=4;
        //描述行为
        public void run()       
                {
                        System.out.println(num+"::"+color);
       
                }
       
}
前者输出时5：：green，前者在堆内存中只有一个对象，当Car c1=c时，是将c中建立的对象的地址给了c1，
那么在c1.color=”green“改的是c中建立的对象的颜色。
后者在Car c1=new Car();时在对内存中建立了一个新的对象，当c1.color="green"改的是c1中的颜色，c中颜色未变。
为什么c.run()打印结果也是5：：green？

首先 你在描述car属性的时候num=4 color为red，
class Car
{
        //描述颜色
        String color="red";
        //描述轮胎数
        int num=4;
        //描述行为
接着 你建立了Car c 对象并且将num的值改为5，之后又建立了Car c1对象然后
把c的地址值传给了c1 到这里 c的属性为num=5,color=red.之后你将c1的color属性改为green，而这2个对象引用是相同的
意思就是由于c1=c所以他们引用指向同一组数据，你改变c1之后，c肯定会跟着改变的。他们储存的地址值是一样的。
所以 输出的结果是5和green


希望对你有帮助

------------
Car c=new Car();
c.num=5;
Car c1=c;
c1.color="green";
c.run();
------------
Car c=new Car();
c.num=5;
Car c1=new Car();
c1=c;
c1.color="green";
c.run();
---------------
这么说吧 两次的情况都是把c的引用传递给了c1 所以一个变两个都会变
c.run();和c1.run();的打印结果相同；
可以这么简单理解：
因为 Car c=new Car();Car c1=new Car();又 c1=c;
所以c1=new Car()=c; 所以俩引用相同

前者中Car c1=c;执行完，c和c1指向同一个对象，c和c1是对同一个属性值的修改。
后者将c对象的引用赋给c1,那么c1也指向c对象，c1指向的原来对象由于没有引用只想它，所以就会被垃圾收集器在适当时候收集，所以，c1和c还是指向c所指向的对象。c1对color的修改，就是c对象中color的值。
总结：两个引用类型变量(假设它们都不为空)的相互赋值不会导致它们所引用的对象自身被复制，其结果是这两个引用类型的变量引用同一个对象。

我一步一步的帮你分析：
//声明Car的引用变量并创建Car对象，然后将Car对象赋值给引用变量c
Car c=new Car();//对象1
//改变该对象中的num
c.num=5;

//声明Car的引用变量并创建Car对象，然后将Car对象赋值给引用变量b
Car c1=new Car();//对象2

//将变量c的值赋予变量c1，注意：此时c开始指向的对象1被抛弃。也就是该指向断开。
c1=c;
//二者共同指向对象2
c1.color="green";
//c1的颜色就变成了green ，当然c的颜色就变成了//c1的颜色就变成了 green ，当然c的颜色就变成了

c.run();
//所以打印出了5 green

上图说明吧。

前者的对象c是通过关键字new创建的，执行时在堆中分配对象的地址，在栈中分配color,num的内存，并且两者建立指向关系。当执行语句c.num=5,修改了栈中num的值。car c1=c是在堆中分配一个c1的内存并且将c的地址赋给c1,即两者指向栈中同一个内存，当对c1属性修改时就是对c的修改。所以结果输出5 green。后者，虽然通过new在栈中分配两个内存，但是执行c1=c时，c1指向了c在栈中内存，其原来指向的内存会被释放。c1和c指向的是同一个栈内存单元，所以对任何一个操作都会修改栈中的属性值。输出结果为5 green