函数
1. 一个静态函数fun1中调用另一个函数fun2时， fun2应该也是静态函数
public static int add(int a , int b)
{
return a+b;
}
//主方法，主函数的范围
public static void main(String[] args)//public是权限
{
int x1 = 3 ;
int x2 = 4;
System.out.println(add(x1 , x2));//main函数为静态的， 所以调用的add函数也应该是静态的
}
2. {} 表示局部空间，在{}内的栈变量不能被外界访问
3.局部变量属于方法， 所以首先是主函数进栈，然后再是局部变量进栈。而new产生的为实体，放在堆里， 会给new的变量一个默认初始值，比如：
boolean默认为false，小数0.0或者0.0f,char '\u0000' , \u表示unicode码
类
匿名对象：没有名字的对象：
new Car(); //匿名对象其实就是定义对象的简写格式。
Car c = new Car();
c.run();
用匿名对象来书写以上代码：
new Car().run();
匿名对象的使用方法：
1 当对象对方法仅进行一次调用的时候，就可以简化成匿名对象。
如一个 对象需要进行调用方法2次，用匿名对象的
new Car().run()
new Car().run()
这是2个对象分别调用了run()，不是一个对象调用了多方法。
2 匿名对象可以作为实际参数进行传递。
匿名对象的内存分析：
2.构造函数中有return；语句
3. 一般函数不能调用构造函数，因为构造函数的作用是初始化对象， 一般函数调用， 连对象都没有，就不能调用构造函数
this关键字
static 关键字
1.main函数为静态函数，所以一本情况下只能调用静态函数，若要调用非静态函数， 则要结合匿名对象方法来调用：
class Demo
{
public static void main(String [] args)
{
new Demo().show();//调用非静态函数
}
public void show()
{
system.out.print();
}
}
2.jvm直接运行的是类 ：java MainDemo；而不是对象，这也说明为什么main函数是static
3./*
静态什么时候用？
1，静态变量。
当分析对象中所具备的成员变量的值都是相同的 。
这时这个成员就可以被静态修饰。
只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。
如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义成静态的。
2，静态函数。
函数是否用静态修饰，就参考一点，就是该函数功能是否有访问到对象中的特有数据。也就是非静态成员变量
简单点说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的。
如果不需要，就可以将该功能定义成静态的。当然，也可以定义成非静态，
但是非静态需要被对象调用，而仅创建对象调用非静态的
没有访问特有数据的方法，该对象的创建是没有意义。
*/
class Demo
{
int age ;
static int num = 9;
Demo(int age)
{
this.age = age;
}
public static void speak()
{
System.out.println(num);
}
public void show()
{
System.out.println(age);
}
}
class StaticDemo3
{
public static void main(String[] args)
{
// Demo d = new Demo(30);
// d.speak();
Demo.speak();
// System.out.println("Hello World!");
}
}静态变量和静态方法能够通过类名来访问，不需要创建一个类的对象来访问该类的静态成员，所以static修饰的成员又称作类变量和类方法。静态变量与实例变量不同，实例变量总是通过对象来访问，因为它们的值在对象和对象之间有所不同。
请看下面的例子：
public class Demo {static int i = 10;int j;Demo() {this.j = 20;}public static void main(String[] args) {System.out.println("类变量 i=" + Demo.i);Demo obj = new Demo();System.out.println("实例变量 j=" + obj.j);}}
运行结果：
类变量 i=10
实例变量 j=20
static 的内存分配
静态变量属于类，不属于任何独立的对象，所以无需创建类的实例就可以访问静态变量。之所以会产生这样的结果，是因为编译器只为整个类创建了一个静态变量的副本，也就是只分配一个内存空间，虽然有多个实例，但这些实例共享该内存。实例变量则不同，每创建一个对象，都会分配一次内存空间，不同变量的内存相互独立，互不影响，改变 a 对象的实例变量不会影响 b 对象。
请看下面的代码：
- public class Demo {
- static int i;
- int j;
- public static void main(String[] args) {
- Demo obj1 = new Demo();
- obj1.i = 10;
- obj1.j = 20;
-
- Demo obj2 = new Demo();
-
- System.out.println("obj1.i=" + obj1.i + ", obj1.j=" + obj1.j);
- System.out.println("obj2.i=" + obj2.i + ", obj2.j=" + obj2.j);
- }
- }
obj1.i=10, obj1.j=20
obj2.i=10, obj2.j=0
注意：静态变量虽然也可以通过对象来访问，但是不被提倡，编译器也会产生警告。
上面的代码中，i 是静态变量，通过 obj1 改变 i 的值，会影响到 obj2；j 是实例变量，通过 obj1 改变 j 的值，不会影响到 obj2。这是因为 obj1.i 和 obj2.i 指向同一个内存空间，而 obj1.j 和 obj2.j 指向不同的内存空间，请看下图：
图1 静态变量内存分配
注意：static 的变量是在类装载的时候就会被初始化。也就是说，只要类被装载，不管你是否使用了这个static 变量，它都会被初始化。
小结：类变量(class variables)用关键字 static 修饰，在类加载的时候，分配类变量的内存，以后再生成类的实例对象时，将共享这块内存（类变量），任何一个对象对类变量的修改，都会影响其它对象。外部有两种访问方式：通过对象来访问或通过类名来访问。