哪位高手能说出private int类型变量与private static int类型变量有什么区别？

对private int变量访问是通过对象访问，需要将该类实例化对像，当实例化多个对象的时候就有多个private int变量存在与内存；对private static int访问是通过类名，直接访问，无需对该类实例化，当有多个对象被实例化的时候多个对象访问private int变量是访问的同一存储空间，即private static int型变量是属于类的，而private int是属于每个对象的

这里就是有static 和没有 static 的区别：
   不管在c#还是在java中，记住加了static修饰符的方法或属性都属于类所有，而没加static的方法或属性归对象所有；
    在程序加载过程中，每一个类只加载一次，对象则是随时new出来的，属性中加了static相当于到这个类中去找；没加，相当于到对象中去找

private int类型变量是非静态成员，是与特定的实例相联系，private static int类型变量是静态成员，属于类，有时需要类中有一个数据成员来表示全体对象的共同特征，就需要使用静态数据成员。

由于都是private的，所以private int 和private static int所声明的成员都只能在类内部用，前者是实例的后者是静态的。
在非静态的方法中，两者都可直接用，前面无需加访问修饰符，如果该方法中定义了同名的局部变量，那么要使用private int所声明的那个成员需在前面加一个(this.)或者(其他实例名.)，要使用private static int 所声明的成员，需在前面加上（类名.）。
在静态的方法中，private static int 所声明的成员可以直接使用，而private int所声明的成员需要一个实例来引用，不能用(this.)，只能用(对象名.)；对于private static int 成员，如果该静态方法中定义了与之同名的局部变量，需在前面加上(类名.)才可访问。

简单点说就是，用了static来修饰类型，以后用到类中方法时候不需要实例化这个类，直接调用名字就行了。。。。

static意思是静态，可以修饰类、字段、属性、方法

标记为static的就不用创建实例对象调用了，也就是不能new了，但可以通过类名直接点出来

不加static的private就是指这个类私有的，只能在本类中访问

楼上们，都说的非常好，就不重复了

private是访问修饰符，代表私有的，如果变量用这个修饰符，代表这个变量只能在这个类中使用，其它类中无法使用，
static 是静态修饰符，用了static的变量就是静态变量
它不能通过类的实例访问，只能通过类名直接访问
类的所有实例，共享静态变量的数据，当这个变量的值发生改变，其它实例的这个字段也将发生改变

private int是私有变量，private static int私有静态变量。
私有静态变量所在过程结束时，变量并不释放，下次过程执行时接着使用，只有当程序结束时才释放。

private int是私有变量，private static int私有静态变量。

1. class Program
   
2.     {
   
3.         static void Main(string[] args)
   
4.         {
   
5.             A a = new A();
   
6.             a.Method();//输出i=1,j=1;
   
7.             A b = new A();
   
8.             b.Method();//输出i=1;j=2;
   
9.             Console.ReadKey();
   
10.         }
    
11.     }
    
12. 
    
13.     class A
    
14.     {
    
15.         private int i = 0;
    
16.         private static int j = 0;
    
17. 
    
18.         public void Method()
    
19.         {
    
20.             i++;
    
21.             j++;
    
22.             Console.WriteLine("i={0},j={1}", i, j);
    
23.         }
    
24.     }

复制代码

i和j在内存中存放的位置不同，
一个对象new出来以后，指向的是同一个j，不同的i

两者的差别正是由static决定的。不加static，声明的就是一个私有的实例变量，要想使用这个变量，就得生成一个具体的对象，通过这个对象来调用它。
如果加了static的话，就是一个静态的类变量，属于一个类里公有的变量，不需要生成一个对象，直接可以用类名.变量名来使用。

两者的差别正是由static决定的。不加static，声明的就是一个私有的实例变量，要想使用这个变量，就得生成一个具体的对象，通过这个对象来调用它。
如果加了static的话，就是一个静态的类变量，属于一个类里公有的变量，不需要生成一个对象，直接可以用类名.变量名来使用。

private int  age是一个私有的 int类型,, 在new出一个实例的时候,程序将会给每个实例分配一段存贮 age 的空间.  可以这么说, age这个时候 属于 对象的.

private static int age  在它前面加了 static, 那么 程序只是在 类里面分配了一段公共的空间去存放age,这段空间是属于类的,, 我们new多个对象的时候, 如果在多个对象里面分别赋值, 然后再调用方法 打印出 age 的值, 会发现, age 的结果是 最后一个赋值的结果, 而不是 我们给对象分别赋值的不同结果.

例子::
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 测试static
{
    class Perseon
    {
       static int  age;

        public int Age
        {
            get { return age; }
            set { age = value; }
        }

        string name;

        public string Name
        {
            get { return name; }
         
        }

        public Perseon(string name)
        {
            this.name = name;
        }

        public void Show()
        {
            Console.WriteLine("我叫{0}, 我的年龄是:{1}", name, age);
        }


    }
    class Program
    {
        static void Main(string[] args)
        {
            Perseon zs = new Perseon("张三");
            zs.Age = 18;

            Perseon ls = new Perseon("李四");
            ls.Age = 16;

            zs.Show();
            ls.Show();

            Console.ReadKey();

        }
    }
}

输出结果:
我叫张三, 我的年龄是:16
我叫李四, 我的年龄是:16


可以看出,,  张三 李四的 成绩都是 16,,  赋值的时候 其实在更改同一段内存里的数据

结论: 加  static  的 字段 是属于  类的 , 多个对象 共用这个字段,,,,
不加 static 的字段 是属于 对象的,  new出 对象(实例) 的时候, 会分别给每个对象分配一段空间存贮不 加 static 的字段