Java基础二------函数,类

函数

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 匿名对象可以作为实际参数进行传递。

public static void show(Car c)

{

//......

}

show(new Car());

匿名对象的内存分析：

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 修饰，在类加载的时候，分配类变量的内存，以后再生成类的实例对象时，将共享这块内存（类变量），任何一个对象对类变量的修改，都会影响其它对象。外部有两种访问方式：通过对象来访问或通过类名来访问。