面向对象(Static关键字+main函数)-第12天
面向对象(Static关键字+main函数)
1、面向对象(Static关键字)
static语句：见下图1。
静态：static
用法：是一个修饰符，用于修饰成员（成员变量，成员函数）
class Person
{
String name;
String country="CN";
public void show()
{
system.out.println(name+"::"+country);
}
}
class StaticDemo
{
public static void main(String[] args)
{
Person p=new Person();
p.name="zhangsan";
p.show();//打印zhangsan::CN
}
}
Person p=new Person();
Person p1=new Person();
发现这两个对象有共同的内容（country）。//即多个对象中存在共同数据。见下图2。
如果对象建立的越多，内存中的country越多，那么这样就比较耗费内存空间。
那么我们就可以把共同的数据提取出来，谁要用就找它。见下图3。
这个时候就用到了关键字static
class Person
{
String name;
static String country="CN";
public void show()
{
system.out.println(name+"::"+country);
}
}
class StaticDemo
{
public static void main(String[] args)
{
Person p=new Person();
p.name="zhangsan";
p.show();//打印zhangsan::CN
}
}
用法2：当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用。类名.静态成员。
class Person
{
Stringname;//成员变量，实例变量，对象的变量。
static String country="CN";//静态的成员变量，类变量。
publicvoid show()
{
system.out.println(name+"::"+country);
}
}
class StaticDemo
{
publicstatic void main(String[] args)
{
system.out.println(Person.country);//打印CN
}
}
那么country存放在哪里呢？见下图4。
静态static特点：
1，随着类的加载而加载。
当类Person加载到内存中，country就已经在内存中开辟好了空间。类消失，country消失。说明它的生命周期最长。
2，优先于的对象存在。
明确一点：静态是先存在的。对象是后存在的。
3，被所有对象所共享。
4，可以直接被类名所调用。
实例变量和类变量的区别：
1、存放位置。
类变量随着类的加载而存在于方法区中。随着类的消失而消失。、
实例变量随着对象的建立而存在于堆内存中。
2生命周期。
类变量生命周期最长，随着类的消失而消失。
实例变量生命周期随着对象的消失而消失。
静态使用注意事项：
class Person
{
String name;
static String country="CN";
public static void show()//方法变成静态。
{
system.out.println("::"+country);
}
}
class StaticDemo
{
public static void main(String[] args)
{
Person.show();//::CN
}
}
1，静态方法只能访问静态成员。
class Person
{
String name;
static String country="CN";
public static void show()//方法变成静态。
{
system.out.println("::"+this.name);//name是非静态的。
haha();//方法haha也是非静态的。
}
public void haha()
{}
}
class StaticDemo
{
public static void main(String[] args)
{
Person.show();//执行报错。。
}
}
非静态方法既可以访问静态，也可以访问非静态。
2，静态方法中不可以定义this，super关键字。
因为静态优先于对象存在。所以静态方法中不可以出现this字样。
静态的利弊。
利：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。
可以直接被类名调用。
弊：生命周期过长。
访问出现局限性。（静态虽好，只能访问静态。）
3，主函数是静态的。
java的类库中有大量的静态方法。用static便于调用这个方法。
2、面向对象(main函数)
public static void main(String[] args)
主函数是一个特殊的函数，作为程序的入口，可以被jvm虚拟机调用。
public：代表该函数访问权限是最大的。
static：代表主函数随着类的加载就已经存在了。
void：主函数没有返回值。
main:不是关键字，但是是一个特殊的单词，可以被jvm虚拟机识别。
(String[] args)：函数的参数，参数类型是一个数组，该数组中的元素是字符串。也就是字符串类型的数组。
主函数是相对固定格式的：jvm虚拟机会识别。
class MainDemo
{
public static void main(String[]args)//jvm虚拟机只识别这个函数
{
system.out.println("country");
}
public static void main(int x)//这样相当于函数重载。！！！
{
}
}
args可以改变吗？
class MainDemo
{
public static void main(String[] x)//编译通过。！！！靠谱，x代替args。arguments的简写
{
system.out.println("country");
}
}
class MainDemo
{
public static void main(String[] args)
{
system.out.println(args);//打印[Ljava.lang.String;@de6ced。即打印的是数组地址，见下图1。
}
}
class MainDemo
{
public static void main(String[] args)
{
system.out.println(args.length);//打印0。说明了args里面的数组长度为0，0个元素。
}
}
jvm在调用主函数时，初始化传递的是new String[0];
class MainDemo
{
public static void main(String[] args)
{
system.out.println(args[0]);//编译通过，运行错误。越界了。String[0]这个叫0个元素。而args[0]代表第一个元素
}
}
//打印：ArrayIndexOutOfBoundsExpcetion
分析编译过程：见图2.
当运行的时候，在java的后面加上一些元素会有不同的变化。
即在dos下，运行的时候输入：java class MainDemo haha hehe heihei
class MainDemo
{
public static void main(String[] args)
{
system.out.println(args[0]);//打印haha
}
}
//运行的时候见图3.
class MainDemo
{
public static void main(String[] args)
{
system.out.println(args.length);//打印3
system.out.println(args[0]);//打印haha
}
}//见图4
换一种方法：
class MainDemo
{
public static void main(String[] args)
{
String[]arr={"hah","heh","heihei","xixi"};
MainTest.main(arr);//类名.静态方法()。静态的调用
}
class MainTest
{
public static void main(String[] args)
{
for(int x=0;x
{
system.out.println(args[x]);//同样分别打印"hah","heh","heihei","xixi"。
}
}
}