菜鸡的Java笔记 第十七 static 关键字
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方法大部分情况下有两种可能性
可以不受到类实例化的对象控制
类中就没有提供有普通属性
*/