public class Test {
static int age; //由static修饰，静态属性
int classNum;
public static void main(String[] args) {
Test person = new Test(); //在这个对象中赋值，12给了classNum，它是非静态属性，所以只在本空间中存在
person.classNum = 12;
person.age = 20; //20给了静态属性，也就是说它存在于方法区，所有对象共用
//非静态属性
System.out.println("person中classNum的值：" + person.classNum);//person中classNum的值：12
System.out.println("person中age的值：" + person.age);//person中age的值：20
Test person2 = new Test(); //因此，在这个新建的空间中，classNum获取不到值，但是age能获取得到20
//非静态属性
System.out.println("person2中classNum的值：" + person2.classNum);//person2中classNum的值：0
System.out.println("person2中age的值：" + person2.age);//person2中age的值：20
}
}
package com.qianfeng.day07.demo4;
public class Pet2 {
staticint i = 0;
/*运用场景：
* 1、所有的对象共用某一个属性时，使用静态属性
* 2、跟final 一起使用，可以当常量用
* 3、国际化字符切换*/
publicPet2() {
i++;
method();
}
publicstatic void method() {
System.out.println("生成的是第" + i + "个对象");
}
publicstatic void main(String[] args) {
for(int j = 0; j < 10; j++){
newPet2();//所有的对象共用某一个属性时,这里有10个对象，哈哈，明白啦
}
System.out.println(Pet2.i);
}
}
public class Pet {
String name;
static int i; //静态属性。只能被静态方法使用。如果把static去掉，变为非静态属性，则报错，
//因为编译时是方法区先启动，无法加载非静态属性
public static void main(String[] args) {
Pet cat=new Pet();
cat.name="猫"; //运行到这里后，“猫”通过cat.name传入到成员变量里，再返回到对象中输出
i++; //i为0，i++之后变1。
Pet dog=new Pet();
dog.name="狗";
i++;//i为1，i++之后变2
Pet birg =new Pet();
birg.name="鹦鹉";
i++;//i为2，i++之后变3
System.out.println(i);
}
}
package com.qianfeng.day07.demo4;
public class Static {
/**
* 静态属性：
* 1、使用static进行修饰
* 2、属于类， 使用类名.属性进行访问， 也可以使用对象名.属性 (不建议使用)
* 3、不能出现在非静态方法中，非静态块中
* 4、如果跟fianl关键字使用时，表示常量，而变量名写法有个习惯
* eg : PARAM_VALID_ILLEGAL_REQUEST
*
* //选中：shift + ctrl + x 小写转大写
* 运用场景：
* 1、所有的对象共用某一个属性时，使用静态属性
* 2、跟final 一起使用，可以当常量用
* 3、国际化字符切换
*
* 静态方法
* 1、使用static进行修饰
* 2、属于类， 使用类名.方法进行访问， 也可以使用对象名.方法 (不建议使用)
* 3、静态方法中不能调用非静态方法，非静态属性
*
* 运用场景：
* 1、工具类 (比如：Math.max) XmlUtil JsonUtil DBUtil
*
* 静态代码块
* 1、使用static进行修饰
* 2、类进行加载时，就开始执行了，并且执行一次
* 3、静态方法，属性，块，是有顺序要求，谁排在前面，谁先加载
*
* 运用场景：
* 1、操作数据库时，建立连接时使用
* 2、初始化系统(项目)参数
*/
publicstatic void main(String[] args) {
}
}
package com.qianfeng.day07.demo4;
public class StaticBlock {
intage;
static{
//知识点：静态块执行顺序
//类进行加载时，就开始执行了，并且执行一次
//运用场景：
// >> 操作数据库时，建立连接时使用
// >> 初始化系统(项目)参数
System.out.println("静态块");
//Cannot make a static reference to thenon-static field age
//System.out.println(age);
//Cannot reference a field before it isdefined
//注意点：静态方法，属性，块，是有顺序要求，谁排在前面，谁先加载
//System.out.println(staticAge);
}
//staticint staticAge;
//非静态块 非静态成员代码块
//在创建对象前，进行调用，即在调用构造方法前调用
//每次创建对象，都会调用
//实际项目中，很少使用， 初始化作用，但是跟构造方法初始属性功能重复了
{
System.out.println("非静态块");
}
publicStaticBlock(){
System.out.println("构造方法");
}
publicstatic void main(String[] args) {
/*StaticBlock staticBlock = new StaticBlock();
StaticBlock staticBlock2 = newStaticBlock();
StaticBlock staticBlock3 = newStaticBlock();
StaticBlock staticBlock4 = newStaticBlock();
StaticBlock staticBlock5 = newStaticBlock();*/
System.out.println("--------------");
new StaticBlock();
System.out.println("-------------2-");
new StaticBlock();
System.out.println("-------------3-");
//int i = 0;
//局部代码块
/*{
inti = 1;
}*/
//i cannot be resolved to a variable
//System.out.println(i);
}
}
package com.qianfeng.day07.demo4;
public class StaticField {
//-----静态属性的研究------
StringfieldStr; //普通属性 它属于对象
/*
* 1、static 关键字修饰的属性 方法，表示为静态属性，静态方法
* 2、static 修饰的属性或者方法，它属于类的
* 3、static 修饰属性或者方法，它存在方法区里面，是一个全局变量(或方法)，而且唯一
* 所有的对象都共用。
*/
staticString staticFieldStr; // 静态属性
publicstatic void main(String[] args) {
//普通属性的访问方式
StaticField staticField = newStaticField();
//Cannot make a static reference to thenon-static field fieldStr
//原因：fieldStr 是对象的属性，在静态方法中访问，无法确定是哪一个的属性
//所以无法方法，必须指定具体的对象
//System.out.println(fieldStr); //错的
System.out.println(staticField.fieldStr);//正确的
//静态属性的访问方式
//因为staticFieldStr 静态的属性，它属于类，而且存在于方法区中，且是唯一的一份
//公共的，所有在static 方法中可以访问
System.out.println(staticFieldStr);//正确的
}
}
package com.qianfeng.day07.demo4;
public class StaticMethod {
intage; //非静态
staticint staticAge;//静态
/*
* 非静态方法
*/
publicvoid method(){
System.out.println("StaticMethod.method()");
staticMethod();
}
/*
* 静态方法
* 1、静态方法属于类方法，使用类名.方法进行访问
* 2、静态方法中不能调用非静态方法，可以调用静态的方法
* 因为：非静态方法属于对象，调用前提是必须有对象存在，而.class加载时，
* 静态方法同时加载入方法区，此时，没有创建任何对象，如果通过类名.方法
* 访问时，如果静态方法中调用的非静态方法，那么只能报错，因为没有对象
* 提供用于非静态方法的访问
* 3、静态方法不能访问非静态属性，原理跟2一样
* 4、不能再静态方法中使用this关键字
* 5、非静态方法可以访问静态方法，静态属性
*/
publicstatic void staticMethod(){
//Cannot make a static reference to thenon-static method method()
//from the type StaticMethod
//method();
StaticMethod staticMethod = newStaticMethod();
staticMethod.method(); //对象调用了
//访问非静态属性
//Cannot make a static reference to thenon-static field age
//System.out.println(age);
//访问静态属性
System.out.println(staticAge);
System.out.println("StaticMethod.staticMethod()");
}
publicstatic void main(String[] args) {
StaticMethod.staticMethod(); //本类中
}
}
package com.qianfeng.day07.demo4;
public class Test {
publicstatic void main(String[] args) {
//非静态属性
StaticField sf = new StaticField();
System.out.println(sf.fieldStr);
//静态属性
//静态属性访问：类名.具体的静态属性 / 方法
System.out.println(StaticField.staticFieldStr);
//The static fieldStaticField.staticFieldStr should
//be accessed in a static way
//不提倡通过对象进行访问静态属性或方法
//System.out.println(sf.staticFieldStr);
//非本类调用静态方法
StaticMethod.staticMethod();
}
}
package com.qianfeng.day07.demo4;
public class A {
Aa = new A();//a在Class文件中创建了，在.class文件加载时会不会也同时在堆内存中开辟对象的空间？
//要是也开辟了空间的话，有a去调用非静态方法，再用静态方法去接收，不是也可以？
//答：不行，因为这时候还没开辟空间，执行程序后是先加载tatic。
publicstatic void method1(){
}
publicvoid method2(){
}
publicstatic void main(String[] args) {
A aa = new A();
}
}
package com.qianfeng.day07.demo4;
public class Activity {
publicstatic String TAG = "Activity";
intage = 10;
//常量
staticfinal int age2 = 10;
}
302
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
