面向对象-静态变量与单例设计模式

1. Static

1.1 什么是Static

1. static：静态的
2. static可以用来修饰：方法、属性、代码块、内部块

1.2 Static的使用

1.2. 1static修饰属性：静态变量;

1. 属性：按是否使用static修饰，又分为静态变量 vs 非静态变量

• 实例变量：当我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性，当修改其中一个对象中的非静态属性时，不会导致其它对象中同样的属性值修改

2. 静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量，当通过某一个对象修改静态变量时，会导致其它对象调用此静态变量时，是修改过了的
   3. static修饰属性的其它说明：
   • 静态变量随着类的加载而加载，可以通过类.静态变量的方式进行调用
   • 静态变量的加载要早于对象的创建
   • 由于类只会加载一次，则静态变量在内存中也只会存在一份，存在方法区的静态域中

1.2.1.1 静态变量和实例变量的内存解析

1.2.2 使用static修饰方法：静态方法

1. 随着类的加载而加载，可以"类.静态方法"的方式进行调用
2. 静态方法中，只能调用静态的方法或属性
3. 非静态方法中，既可以调用普通方法或属性，也可以调用静态的方法或属性
4. static 注意点
   +：在静态的方法中不能使用this关键字或 super关键字

1.3 开发中，是否要声明为static？

1. 属性是否需要声明static：
   • 属性是可以被多个对象所共享的，不会随着对象的不同而不同的。
2. 方法是否需要声明static：
   • 操作静态属性的方法，通常设置为static的
   • 工具类中的方法，习惯上声明为static的，比如 Math、Arrays、Collections ，这样就不需要创建对象调用方法

相关代码

public class StaticTest {
	public static void main(String[] args) {
		
		Chinese.nation = "中国";
		
		
		Chinese c1 = new Chinese();
		c1.name = "姚明";
		c1.age = 40;
		c1.nation = "CHN";
		
		Chinese c2 = new Chinese();
		c2.name = "马龙";
		c2.age = 30;
		c2.nation = "CHINA";
		
		System.out.println(c1.nation);
		
		//编译不通过
//		Chinese.name = "张继科";
		
		
		c1.eat();
		
		Chinese.show();
		//编译不通过
//		Chinese.eat();
//		Chinese.info();
	}
}
//中国人
class Chinese{
	
	String name;
	int age;
	static String nation;
	
	
	public void eat(){
		System.out.println("中国人吃中餐");
		//调用非静态结构
		this.info();
		System.out.println("name :" +name);
		//调用静态结构
		walk();
		System.out.println("nation : " + nation);
	}
	
	public static void show(){
		System.out.println("我是一个中国人！");
		//不能调用非静态的结构
//		eat();
//		name = "Tom";
		//可以调用静态的结构
		System.out.println(Chinese.nation);
		walk();
	}
	
	public void info(){
		System.out.println("name :" + name +",age : " + age);
	}
	
	public static void walk(){
		
	}
}

2 设计模式

设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格以及解决问题的思考方式。

2.1 单例模式

2.1.1 懒汉式和饿汉式的区别

1. 饿汉式:

坏处：对象加载时间过长。
好处：饿汉式是线程安全的

2. 懒汉式：

好处：延迟对象的创建。
目前的写法坏处：线程不安全。—>到多线程内容时，再修改

2.1.2 单例模式的优点

由于单例模式只生成一个实例，减少了系统性能开销

2.1.3 单例模式 应用场景

3. 代码块

package com.atguigu.java3;
/*
 * 类的成员之四：代码块（或初始化块）
 * 
 * 1. 代码块的作用：用来初始化类、对象
 * 2. 代码块如果有修饰的话，只能使用static.
 * 3. 分类：静态代码块  vs 非静态代码块
 * 
 * 4. 静态代码块
 * 	   >内部可以有输出语句
 * 	   >随着类的加载而执行,而且只执行一次
 * 	   >作用：初始化类的信息
 * 	   >如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
 * 	   >静态代码块的执行要优先于非静态代码块的执行
 * 	   >静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构
 * 
 * 5. 非静态代码块
 * 		>内部可以有输出语句
 * 		>随着对象的创建而执行
 * 		>每创建一个对象，就执行一次非静态代码块
 * 		>作用：可以在创建对象时，对对象的属性等进行初始化
 * 		>如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
 * 		>非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法
 * 
 */
public class BlockTest {
	public static void main(String[] args) {
		
		String desc = Person.desc;
		System.out.println(desc);
		
		Person p1 = new Person();
		Person p2 = new Person();
		System.out.println(p1.age);
		
		Person.info();
	}
}


class Person{
	//属性
	String name;
	
	int age;

	static String desc = "我是一个人";
	
	//构造器
	public Person(){
		
	}
	public Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	
	//非static的代码块
	{
		System.out.println("hello, block - 2");
	}
	{
		System.out.println("hello, block - 1");
		//调用非静态结构
		age = 1;
		eat();
		//调用静态结构
		desc = "我是一个爱学习的人1";
		info();
	}
	//static的代码块
	static{
		System.out.println("hello,static block-2");
	}
	static{
		System.out.println("hello,static block-1");
		//调用静态结构
		desc = "我是一个爱学习的人";
		info();
		//不可以调用非静态结构
//		eat();
//		name = "Tom";
	}
	
	//方法
	public void eat(){
		System.out.println("吃饭");
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	public static void info(){
		System.out.println("我是一个快乐的人！");
	}
	
}

4. final关键字

1. final 用来修饰一个类：此类不能被其他类继承
2. final用来修饰一个方法：表明此方法不能被重写
3. final用来修饰变量：此时的变量就称为一个常量
   • 尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。