面向对象（初识）

一个文件里面一般只存放一个类

 1 package com_package2;
 2 
 3 public class Car {
 4     String color;
 5     int num;
 6     void run()
 7     {
 8        int num=10;
 9        System.out.println(color+" "+num);
10         
11     }
12 
13 }

 1 package com_package2;
 2 
 3 public class CarDemo {
 4     public static void main(String[]args)
 5     {
 6         Car car =new Car();//创建Car类对象，通过new关键字完成，这个对象来源于上端源代码产生的class文件，左边定义了一个Car类型的car变量，也称为类类型变量，类类型变量指向该类对象
 7         car.color="blue"; //指挥汽车做事情，调用格式：对象.对象成员,改变的是car指向的内存中的对象中的color的值，并不是上边color的属性
 8         car.num=4;
 9         car.run();
10         Car c = new Car();
11         c.color="yellow";
12         c.num=5;
13         c.run();
14         Car c1 = new Car();
15         c1.color="green";
16         c1.num=3;
17         c1.run();
18         show(car);
19         show(c);
20         show(c1);
21         car.run();
22         c.run();
23         c1.run();
24     }
25     public static void show(Car cc)
26     {
27         cc.color="red";
28         cc.num=9;
29         cc.run();
30         
31     }
32     
33      
34        
35 }

blue 10
yellow 10
green 10
red 10
red 10
red 10
red 10
red 10
red 10

 1 package com_package2;
 2 
 3 public class CarDemo {
 4     public static void main(String[]args)
 5     {
 6         Car car =new Car();//创建Car类对象，通过new关键字完成，这个对象来源于上端源代码产生的class文件，左边定义了一个Car类型的car变量，也称为类类型变量，类类型变量指向该类对象
 7         car.color="blue"; //指挥汽车做事情，调用格式：对象.对象成员,改变的是car指向的内存中的对象中的color的值，并不是上边color的属性
 8         car.num=4;
 9         car.run();
10         Car c = new Car();
11         c.color="yellow";
12         c.num=5;
13         c.run();
14         Car c1 = new Car();
15         c1.color="green";
16         c1.num=3;
17         c1.run();
18         car.run();
19         c.run();
20         c1.run();
21         show(car);
22         show(c);
23         show(c1);
24         car.run();
25         c.run();
26         c1.run();
27     }
28     public static void show(Car cc)//类似于Car cc = new Car();
29     {
30         cc.color="red";
31         cc.num=9;
32         cc.run();
33         
34     }
35     
36      
37        
38 }

blue 10
yellow 10
green 10
blue 10
yellow 10
green 10
red 10
red 10
red 10
red 10
red 10
red 10

这里是不是发现了什么？

因为run（）内定义的局部变量和成员变量虽然名字相同但是并不是互相干涉的，既然run（）内包含num变量，那么优先输出run中num的值，如果run中没有num就会输出成员变量num=4

只有包含main的类才可以运行

这里也体现出了局部变量和成员变量之间的区别：

1、定义的位置不同。

成员变量定义在类，作用于整个类。

局部变量定义在函数，作用于整个函数，或者定义在语句，作用于语句内。

2、内存出现的时间和位置不同。

成员变量：当对象创建是，出现在堆内存的对象中。

局部变量：所属区间被运算时，出现在栈内存中。

3、生命周期不同：

成员变量：随着对象的出现而出现，随着对象的消失而消失。

局部变量：随着所属区间运算结束而立即被释放。

4、初始化值：

成员变量：因为在堆内存中，都有默认的初始化。

局部变量：没有默认初始化。

 1 package com_package2;
 2 
 3 public class Demo {
 4     
 5     public static void main(String[]args)
 6     {
 7         int x=2;
 8         show(x);
 9         System.out.println("x="+x);
10         
11         
12     }
13     public static int show(int x)
14     {
15         x=4;
16         return x;
17         
18     }
19 
20 }

首先看这段代码：打眼一看可能一猜结果是x=4

但是实际运行出来的结果不是4而是x=2,因为这里面涉及到一个栈的结构

首先main（）进栈，栈底变成了x=2,运行到show（），show（）进栈，栈顶是show（），x=4,然后show（）出栈，最后出栈的是main()，x=2.

 1 package com_package2;
 2 
 3 public class Demo2 {
 4      int x=3;
 5      public static void main(String[]args)
 6      {
 7          Demo2 d =new Demo2();
 8          d.x=5;
 9          System.out.println(d.x);
10          show(d);
11          System.out.println(d.x);
12          
13      }
14      public static void show(Demo2 s)
15      {
16          s.x=4;
17          
18          
19          
20      }
21 }

这一段的代码有可能猜中5 4

原理：不同的操作对内存当中的统一对象做不同的改变，无论怎么改改的都是同一个对象，后面的对象对前面的对象进行覆盖

对象区

无论进站出站，都是对同一块内存当中的对象进行的改变