面向对象基础——static关键字和代码块的使用

淡淡的烟草味﹌ 2022-07-28 01:05 222阅读 0赞

## 具体内容 ##

在Java中可以使用static声明属性和方法，因为之前多部分属性和方法都属于非static的，这样一来，每个对象都占有自己的内容，如果现在希望一个属性被所有的对象所共同拥有，则可以将其声明为static类型，声明为static类型的属性和方法之后此属性或方法也称为类非，可以由类名称直接调用。

## 使用static声明属性 ##

static可以声明全局属性，全局属性到底有哪些作用？如下所示

class Person{	// 定义Person类
    	String name ;		// 定义name属性，暂时不封装
    	int age ;			// 定义age属性，暂时不封装
    	String country = "A城" ;	// 定义城市属性，有默认值
    	public Person(String name,int age){
    		this.name = name ;
    		this.age = age; 
    	}
    	public void info(){	// 得到信息
    		System.out.println("姓名：" + this.name + "，年龄：" + this.age + "，城市：" + country) ;
    	}
    };
    public class StaticDemo01{
    	public static void main(String args[]){
    		Person p1 = new Person("张三",30) ;	 // 实例化对象
    		Person p2 = new Person("李四",31) ;	 // 实例化对象
    		Person p3 = new Person("王五",32) ;	 // 实例化对象
    
    		p1.info() ;
    		p2.info() ;
    		p3.info() ;
    	}
    };

![Center][]

以上代码虽然实现了一些基本功能，但是如果此时城市的名称不叫A城， 而改成了B城，如果现在已经产生了5000个对象，name意味着，此时需要修改5000个对象的country属性，所以此时最好使用static关键字进行声明。

使用this修改程式属性

class Person{	// 定义Person类
    	String name ;		// 定义name属性，暂时不封装
    	int age ;			// 定义age属性，暂时不封装
    	static String country = "A城" ;	// 定义城市属性，有默认值，static
    	public Person(String name,int age){
    		this.name = name ;
    		this.age = age; 
    	}
    	public void info(){	// 得到信息
    		System.out.println("姓名：" + this.name + "，年龄：" + this.age + "，城市：" + country) ;
    	}
    };
    public class StaticDemo02{
    	public static void main(String args[]){
    		Person p1 = new Person("张三",30) ;	 // 实例化对象
    		Person p2 = new Person("李四",31) ;	 // 实例化对象
    		Person p3 = new Person("王五",32) ;	 // 实例化对象
    		System.out.println("--------------- 修改之前 -------------") ;
    		p1.info() ;
    		p2.info() ;
    		p3.info() ;
    		p1.country = "B城" ;		// 修改static属性
    		System.out.println("--------------- 修改之后 -------------") ;
    		p1.info() ;
    		p2.info() ;
    		p3.info() ;
    	}
    };

![Center 1][]

修改一个对象的country属性，则其他对象的country属性都会跟着改变。因为country是该类中所有对象共享的变量。

![Center 2][]

每一个对象都拥有各自的堆栈空间，堆内存空间中保存每一个对象的各自的属性，但是所有的static属性是保存在了全局数据区中，所有对象指向全局数据区中的一个内容，所以当一个对象修改之后，所有对象的内容将全部变化。

java中有以下内存区域：

栈内存：可以保存对象的名称（保存，访问的堆内存的地址）

堆内存：保存每个对象的具体属性。

全局数据区：保存static类型的属性

全局代码区：保存所有方法的定义。

一般在调用static属性的时候最好使用类名直接调用，采用“类名.属性”的形式调用。Person.country = "B城";

不但可以直接使用static声明属性，也可以使用static声明方法。

## 使用static声明方法 ##

如果一个方法使用了static关键字进行了声明，则此方法可以直接使用类名称进行调用，下面将之前全部代码中的属性进行了封装。

class Person{	// 定义Person类
    	private String name ;		// 定义name属性，暂时不封装
    	private int age ;			// 定义age属性，暂时不封装
    	private static String country = "A城" ;	// 定义城市属性，有默认值，static
    	public static void setCountry(String c){ // 此方法可以直接由类名称调用
    		country = c ;
    	}
    	public static String getCountry(){
    		return country ;
    	}
    	public Person(String name,int age){
    		this.name = name ;
    		this.age = age; 
    	}
    	public void info(){	// 得到信息
    		System.out.println("姓名：" + this.name + "，年龄：" + this.age + "，城市：" + country) ;
    	}
    };
    public class StaticDemo04{
    	public static void main(String args[]){
    		Person p1 = new Person("张三",30) ;	 // 实例化对象
    		Person p2 = new Person("李四",31) ;	 // 实例化对象
    		Person p3 = new Person("王五",32) ;	 // 实例化对象
    		System.out.println("--------------- 修改之前 -------------") ;
    		p1.info() ;
    		p2.info() ;
    		p3.info() ;
    		Person.setCountry("B城") ;		// 调用静态方法修改static属性的内容
    		System.out.println("--------------- 修改之后 -------------") ;
    		p1.info() ;
    		p2.info() ;
    		p3.info() ;
    	}
    };

![Center 3][]

注意：使用static方法不能调用非static的属性或方法。

例如以下代码就是错误的：

class Person{	// 定义Person类
    	private static String country = "A城" ;	 // 定义静态属性
    	private String name = "Hello" ;
    	public static void sFun(String c){
    		System.out.println("name = " + name) ;	// 错误，不能调用非static属性
    		fun() ;									// 错误，不能调用非static方法
    	}
    	public void fun(){
    		System.out.println("World") ;
    	}
    };

因为static的属性或方法可以在对象没有实例化的时候就直接可以进行调用了，而非static属性必须在对象实例化之后才可以调用。

## static应用一：统计一个类到底产生了多少个对象。 ##

class Demo{	// 定义Person类
    	private static int count = 0 ;	// 所有对象共享此属性
    	public Demo(){
    		count++ ;					 // 只要有对象产生就应该自增
    		System.out.println("产生了" + count + "个对象！") ;
    	} 
    };
    public class StaticDemo06{
    	public static void main(String args[]){
    		new Demo() ;			// 增加新对象
    		new Demo() ;			// 增加新对象
    		new Demo() ;			// 增加新对象
    	}
    };

![Center 4][]

## static应用实例二：可以使用static对对象进行自动的编名操作 ##

class Demo{	// 定义Person类
    	private String name ;			// 保存名字
    	private static int count = 0 ;	// 所有对象共享此属性
    	public Demo(){
    		count++ ;					// 有对象产生就自增
    		this.name = "DEMO-" + count ;	// 自动进行编名操作
    	} 
    	public Demo(String name){
    		this.name = name;			// 可以通过构造赋值
    	}
    	public String getName(){		// 取得姓名
    		return this.name ;
    	}
    };
    public class StaticDemo07{
    	public static void main(String args[]){
    		System.out.println(new Demo().getName()) ;
    		System.out.println(new Demo("LXH").getName()) ;
    		System.out.println(new Demo().getName()) ;
    		System.out.println(new Demo("MLDN").getName()) ;
    		System.out.println(new Demo().getName()) ;
    	}
    };

![Center 5][]

static的使用总结：

使用static声明的属性或方法可以直接由类名调用。

使用static方法的时候一定要注意，只能访问static声明的属性或方法，而非static声明的属性和方法是不能访问的，因为static可以在对象没有实例化时就直接调用，而其他的属性必须在对象实例化之后才能调用。

## 代码块 ##

代码块是指使用\{\}括起来的一段代码，根据位置的不同可以分为四种：普通代码块、构造块、静态代码块、同步代码块，其中同步代码块涉及多线程。

普通代码块：直接定义在方法中的代码块称为普通代码块。

public class CodeDemo01{
    	public static void main(String args[]){
    		{		// 普通代码块
    			int x = 30 ;	// 就属于一个局部变量
    			System.out.println("普通代码块 --> x = " + x) ;
    		}
    		int x = 100 ;		// 与局部变量名称相同
    		System.out.println("代码块之外 --> x = " + x) ;
    	}
    };

![Center 6][]

构造块：将代码块直接定义在类中，则称为构造块。

class Demo{
    	{	// 直接在类中编写代码块，称为构造块
    		System.out.println("1、构造块。") ;
    	}
    	public Demo(){	// 定义构造方法
    		System.out.println("2、构造方法。") ;
    	}
    };
    public class CodeDemo02{
    	public static void main(String args[]){
    		new Demo() ;		// 实例化对象
    		new Demo() ;		// 实例化对象
    		new Demo() ;		// 实例化对象
    	}
    };

![Center 7][]

构造块优先于构造方法执行，且执行多次。。只要一有实例对象产生，就会执行构造快的内容。

静态代码块：直接使用static关键字声明的代码块称为静态代码块。

class Demo{
    	{	// 直接在类中编写代码块，称为构造块
    		System.out.println("1、构造块。") ;
    	}
    	static{	// 使用static，称为静态代码块
    		System.out.println("0、静态代码块") ;
    	}
    	public Demo(){	// 定义构造方法
    		System.out.println("2、构造方法。") ;
    	}
    };
    public class CodeDemo03{
    	static{		// 在主方法所在的类中定义静态块
    		System.out.println("在主方法所在类中定义的代码块") ;
    	}
    	public static void main(String args[]){
    		new Demo() ;		// 实例化对象
    		new Demo() ;		// 实例化对象
    		new Demo() ;		// 实例化对象
    	}
    };

![Center 8][]

静态块优先于主方法执行，如果在普通类中定义的静态块优先于构造块执行，不管有多少个实例化对象产生，静态代码块只执行一次，静态代码块的主要功能就是为静态属性初始化。

例如：不使用主方法就能达到执行某些操作的功能。

public class CodeDemo04{
    	static{
    		System.out.println("Hello World!!!") ;
    		System.exit(1) ;	// 程序退出
    	}
    };

[Center]: /images/20220727/c86037d0304240eaaf1f32eaae6e34a9.png
[Center 1]: /images/20220727/f2f7f00483ab4240b967f1d525f1bf62.png
[Center 2]: /images/20220727/90093bbd2c9f4e5abe5d22def401ff46.png
[Center 3]: /images/20220727/6482c12b156445379c32d7e465325018.png
[Center 4]: /images/20220727/bc6f47a1ec4c4849a3d83bce27a181d1.png
[Center 5]: /images/20220727/5a831d9ddc094947a5a9c1551f349ad4.png
[Center 6]: /images/20220727/98be7c46ced2479faa272bb50172146a.png
[Center 7]: /images/20220727/4da5418bd0e24eff8fd6b6effbac32b5.png
[Center 8]: /images/20220727/d80118e6fccd407c97fb08fef99d7ee7.png