static 是java中定义的一个关键字,主要是描述全局的概念,所以利用static关键字可以定义属性,定义方法
但是在90%的情况下,我们的开发代码很少会去直接编写static
*/
/* 利用static定义属性
现在假设定义一个只描述中国人的类,那么在这个类里面肯定要包含有姓名,年龄,国家,
所以按照之前所学的概念来进行设计,就可以的出如下的结果:
class Person{
private String name:
private int age:
String country = "中华人民共和国": // 此属性暂时不封装
public Person(String name,int age){
this.name = name:
this.age = age:
}
public String getlnfo(){
return"姓名"+this.name+"年龄"+this.age+"国籍"+this.country:
}
}
public class staticKeyword{
public static void main(String args[]){
Person perA = new Person("小",10):
Person perB = new Person("中",20):
Person perC = new Person("大",30):
System.out.println(perA.getlnfo()):
System.out.println(perB.getlnfo()):
System.out.println(perC.getlnfo()):
}
}
/*
结果:
姓名;小,年龄;10,国籍;中华人民共和国
姓名;中,年龄;20,国籍;中华人民共和国
姓名;大,年龄;30,国籍;中华人民共和国
*/
但是对于以上的程序的内存关系中就会发现问题所在了
如果说现在玩穿越了,中国退回到了唐朝,中国14亿人口,14亿对象,14亿对象修改一个属性
class Person{
private String name:
private int age:
String country = "中华人民共和国": // 此属性暂时不封装
public Person(String name,int age){
this.name = name:
this.age = age:
}
public String getlnfo(){
return"姓名"+this.name+"年龄"+this.age+"国籍"+this.country:
}
}
public class staticKeyword{
public static void main(String args[]){
Person perA = new Person("小",10):
Person perB = new Person("中",20):
Person perC = new Person("大",30):
perA.country = "唐朝":
System.out.println(perA.getlnfo()):
System.out.println(perB.getlnfo()):
System.out.println(perC.getlnfo()):
}
}
/*
结果:
姓名;小,年龄;10,国籍;唐朝
姓名;中,年龄;20,国籍;中华人民共和国
姓名;大,年龄;30,国籍;中华人民共和国
*/
这样的话对于整个代码的维护实在是太可怕,而造成这种问题的根源在于:
类中的普通属性是每一个对象都独自拥有的,但是这样的设计明显不符合当前的环境,所以最好的做法是将国家的这个属性设置为公共属性
所有的对象都可以共享此属性,如果要想实现这样的操作,就可以通过static 关键字来进行定义
范例:使用static关键字定义
class Person{
private String name:
private int age:
static String country = "中华人民共和国": // 此属性暂时不封装
public Person(String name,int age){
this.name = name:
this.age = age:
}
public String getlnfo(){
return"姓名"+this.name+"年龄"+this.age+"国籍"+this.country:
}
}
public class staticKeyword{
public static void main(String args[]){
Person perA = new Person("小",10):
Person perB = new Person("中",20):
Person perC = new Person("大",30):
perA.country = "唐朝": // 修改了一个对象的属性
System.out.println(perA.getlnfo()):
System.out.println(perB.getlnfo()):
System.out.println(perC.getlnfo()):
}
}
/*
结果:
姓名;小,年龄;10,国籍;唐朝
姓名;中,年龄;20,国籍;唐朝
姓名;大,年龄;30,国籍;唐朝
*/
通过执行结果发现,修改了一个对象的属性之后,所有对象的属性都发生了改变
所以这样的属性称为公共属性,公共属性必须通过static定义,而对于公共属性的内容保存不会在栈内存也不在堆内存
而是会存在于全局数据区中,所有的方法保存在全局代码区之中
但是现在出现了一个问题,既然static属于全局属性,那么由一个对象进行修改是否合适呢/
现在通过一个对象改的:
perA.country = "唐朝": // 修改了一个对象的属性
很明显这是不合适的,最好的做法是利用所有对象的一个最高的代表来操作,这个代表就是类
所以对于static定义的属性可以由类名称直接进行调用,所以这样的属性也被称为类属性
Person.country = "唐朝": // 直接通过类调用
此时的类中存在有static属性以及非static属性,但是在这里面需要注意:
所有的非static属性都是在对象实例化的时候才会进行内存的分配
所有的static属性可以在没有实例化对象产生的情况下直接使用
范例:直接调用类属性
class Person{
private String name:
private int age:
static String country = "中华人民共和国": // 此属性暂时不封装
public Person(String name,int age){
this.name = name:
this.age = age:
}
public String getlnfo(){
return"姓名"+this.name+"年龄"+this.age+"国籍"+this.country:
}
}
public class staticKeyword{
public static void main(String args[]){
System.out.println(Person.country):
}
}
/*
结果:
中华人民共和国
*/
修改
class Person{
private String name:
private int age:
static String country = "中华人民共和国": // 此属性暂时不封装
public Person(String name,int age){
this.name = name:
this.age = age:
}
public String getlnfo(){
return"姓名"+this.name+"年龄"+this.age+"国籍"+this.country:
}
}
public class staticKeyword{
public static void main(String args[]){
System.out.println(Person.country):
Person.country = "北宋":
System.out.println(Person.country):
}
}
/*
结果:
中华人民共和国
北宋
*/
---
class Person{
private String name:
private int age:
static String country = "中华人民共和国": // 此属性暂时不封装
public Person(String name,int age){
this.name = name:
this.age = age:
}
public String getlnfo(){
return"姓名"+this.name+"年龄"+this.age+"国籍"+this.country:
}
}
public class staticKeyword{
public static void main(String args[]){
System.out.println(Person.country):
Person.country = "北宋":
System.out.println(Person.country):
System.out.println(new Person("小",10).getlnfo):
}
}
/*
结果:
中华人民共和国
北宋
姓名;小,年龄;10,国籍;北宋
*/
虽然static的属性定义在类之中,但是其是完全独立的,不受类实例化对象的控制
在90%的情况下类的设计都会使用非static属性,只有在10%表示公共的属性,或者是与类实例化无关的属性定义时才会考虑使用static
*/
/* static 定义方法
利用static定义的属性可以直接通过类名称进行访问,但是static也可以用于方法的定义上,同样,这个方法可以由类名称直接进行调用
范例:定义static方法
class Person{
private String name:
private int age:
private static String country = "中华人民共和国":
public Person(String name,int age){
this.name = name:
this.age = age:
}
public static void setCountry(String c){
country = c:
}
public static String getCountry(){
return country:
}
public String getlnfo(){
return"姓名"+this.name+"年龄"+this.age+"国籍"+this.country:
}
}
public class staticKeyword{
public static void main(String args[]){
// 此时没有实例化对象产生
System.out.println(Person.getCountry()):
}
}
/*结果:
中华人民共和国 */
…
class Person{
private String name:
private int age:
private static String country = "中华人民共和国":
public Person(String name,int age){
this.name = name:
this.age = age:
}
public static void setCountry(String c){
country = c:
}
public static String getCountry(){
return country:
}
public String getlnfo(){
return"姓名"+this.name+"年龄"+this.age+"国籍"+this.country:
}
}
public class staticKeyword{
public static void main(String args[]){
// 此时没有实例化对象产生
System.out.println(Person.getCountry()):
Person.setCountry("清朝"):
System.out.println(Person.getCountry()):
System.out.println(new Person("少爷",21).getlnfo()):
}
}
/*
结果:
中华人民共和国
清朝
姓名:少爷。年龄:21,国籍:清朝
*/
static的方法依然不受到实例化对象的控制,所以可以由类名称直接调用
但是此时类中的方法就存在有两种了:static方法,非static方法那么这两种方法之间互相访问就出现问题了
所有的非static方法可以直接调用非static方法或static属性
static 方法只允许调用static方法和static属性
非static方法允许调用 static 和非 static 定义
static 方法不允许调用非 static 操作以及 this
static 定义必须产生实例化对象后才会分配内存空间并且调用,而 static 可以在没有实例化对象的时候进行调用
所以在 static 方法之中不存在有this当前对象概念
class Person{
private String name:
private int age:
private static String country = "中华人民共和国":
public Person(String name,int age){
this.name = name:
this.age = age:
}
public static void setCountry(String c){
country = c:
}
public static String getCountry(){
return country:
}
public String getlnfo(){
System.out.println(this.getCountry()):
return"姓名"+this.name+"年龄"+this.age+"国籍"+this.country:
}
}
public class staticKeyword{
public static void main(String args[]){
System.out.println(new Person("少爷",21).getlnfo()):
}
}
/*结果:
姓名:少爷。年龄:21,国籍:清朝
*/
static 方法不能够直接调用非static方法或者是非static属性
class Person{
private String name:
private int age:
private static String country = "中华人民共和国":
public Person(String name,int age){
this.name = name:
this.age = age:
}
public static void setCountry(String c){// 为什么不是country:因为你在调用static方法时可能还没有实例化对象 所以是 c 也没有加 this
country = c:
}
public static String getCountry(){
getlnfo():
return country:
}
public String getlnfo(){
System.out.println(this.getCountry()):
return"姓名"+this.name+"年龄"+this.age+"国籍"+this.country:
}
}
public class staticKeyword{
public static void main(String args[]){
System.out.println(new Person("少爷",21).getlnfo()):
}
}
//结果:(出错)
分析?为什么会存在有这样的定义?
所有的static属性或方法可以在类没有实例化对象的时候进行直接使用
所有非static属性或方法必须在类产生实例化对象之后才可以进行调用
那么什么时候使用static方法呢?
类设计的过程之中90%的方法都使用非static方法定义
如果一个类中没有任何的属性,那么这个类不需要定义普通方法,只需要定义static方法
范例:对比一下两种代码
1.
class Ssd{
public int add(int x,int y){
return x + y:
}
}
public class staticKeyword{
public static void main(String args[]){
System.out.println(new Ssd().add(10,20)):
}
}
2.
class Ssd{
public static int add(int x,int y){
return x + y:
}
}
public class staticKeyword{
public static void main(String args[]){
System.out.println(Ssd.add(10,20)):
}
}
//结果:30
因为此时Ssd 类没有属性,没有属性就不需要使用到堆内存。
而如果现在使用了第一种方式,那么会开辟一块无用的堆内存空间
所以这个时候很明显,第二种方式更加合理
*/
/* 观察主方法
在最早讲解方法定义的时候实际上给出了两种方案
第一种:某一个方法定义在主类中,并且由主方法直接调用,定义格式:
public static 返回值类型 方法名称(){}
第二种:某一个方法定义在了类中,并且由实例化对象进行调用,定义格式:
public 返回值类型 方法名称(){}
那么现在来做一个简单分析
public class staticKeyword{
public static void main(String args[]){
println():
}
public static void println(){
System.out.println("*****Hello Werld****"):
}
}
/*
结果
*****Hello Werld****
*/
如果没有加 static呢? 那就会出错
但是反过来,这个时候只能够通过产生本类实例化对象的方式来进行调用
public class staticKeyword{
public static void main(String args[]){
new staticKeyword().println(): // 对象。方法()
}
public void println(){ // 非static方法
System.out.println("*****Hello Werld****"):
}
}
在以后所编写的代码过程之中,主类中不会编写什么方法,大部分的方法都会封装在类之中,通过产生对象调用
java 中的主方法可以说是历史之最长的
public:是一种访问权限,表示所有的操作者都可以看见
static:执行一个类的时候输入:“java 类名称”,表示由类直接调用
void:主方法是一切的起点,开始了就继续把
main:是一个系统定义好的方法名称
Stirng args[]:程序执行时的输入参数,初始化参数的
范例:取得初始化输入参数
public class staticKeyword{
public static void main(String args[]){
for(int x = 0:x<args.length:x++){
System.out.println(args[x]):
}
}
}
如果要输入参数,则在解释java 程序时,类后面利用空格设置,每个参数间使用空格区分
执行程序设置参数:java 类名称 内容 例如:Java TestDemo hello world
如果参数本身就有空格则要使用““”声明:Java TestDemo ”hello world“
*/
/* static应用
static在一些系统类库上会大量的出现,那么这些就有可能是static方法所导致的
这次重点来看static属性。static属性有一个最好的特点在于:公共属性,所有对象都可以对其进行修改
范例:实现一个对象的个数统计
所有的新的实例化对象产生式都一定要调用构造方法,所以可以在构造方法里面增加一个统计
class Perdon{
private static int count = 1: // 统计个数
public Peron(){
System.out.println("对象个数:"+count++):
}
}
public class staticKeyword{
public static void main(String args[]){ //
new Person():
new Person():
new Person():
new Person():
new Person():
new Person():
}
}
}
/*
结果:
对象个数:1
对象个数:2
对象个数:3
对象个数:4
对象个数:5
对象个数:6
*/
实际上可以将以上的程序进一步的修改,现在假设Person类中存在有一个name的属性,那么在Person类提供有一个构造方法:
一个是负责接收 name 属性内容的,一个是无参的但是要求不管使用那种构造方法都应该为name属性设置一个名字,而不是nuill
范例:为属性自动命名
class Perdon{
private static int count = 1: // 统计个数
private String name:
public Peron(){
this("无名氏-"+count++):
}
public Person(String name){
this.name = name:
}
public String getName(){
return this.name:
}
}
public class staticKeyword{
public static void main(String args[]){ //
System.out.println(new Person().getName()):
System.out.println(new Person().getName()):
System.out.println(new Person("ssd").getName()):
}
}
}
/*
结果:
无名氏-1
无名氏-2
ssd 3
*/
这样的操作在以后的高级部分会见到其应用
在类的首要设计过程中不要去考虑static属性或者方法
使用static方法大部分情况下有两种可能性
可以不受到类实例化的对象控制
类中就没有提供有普通属性
*/
手机扫一扫
移动阅读更方便
你可能感兴趣的文章