JAVA_SE_Day14

static(静态的)关键字

• static 可以用来修饰 : 属性 方法 内部类 代码块

使用static修饰属性(即静态变量)

• 类的属性用是否使用static修饰可以分为: 静态属性 VS 非静态属性(实例变量)
• 实例变量 : 我们创建了类的多个对象，每一个对象都有一套类中的非静态变量
  当修改其中一个对象中的非静态变量时，不会导致其他对象中同样的属性值的变化
• 静态变量 : 我们创建了类的多个对象，所有对象共享静态变量
  当通过某一个对象修改静态变量时，其他对象调用此静态变量时，时修改后的值
• 静态变量的加载要早于实例对象的创建
• 静态变量的随着类的加载而加载，可以通过"类.静态变量"的方式进行调用
• 由于类只会加载一次，则静态变量在内存中也只会存在一份，存储在方法区的静态域中
• 静态变量举例 Math.PI和System.out

使用static修饰方法(静态方法)

• 随着类的加载而加载，可以通过"类.静态方法"或"实例.静态方法"的方式来调用
• 静态的方法中只能调用静态的方法或属性
  非静态的方法中能调用静态的方法或属性和非静态的方法或属性
• 在静态的方法内，不能使用this和super关键子
• 以上的原因，主要是static的声明周期和普通的结构不同，它随类的加载而加载，当类加载的时候还没有对象以及其非静态的属性和方法

什么时候需要对属性和方法使用static

• 属性 : 属性被多个对象所共享的，不会随着对象的不同而不同，此时这个属性可以设置为static
• static方法 ： 1. 操作静态属性的方法通常设置为static的
  2. 工具类中的方法，习惯上声明为static，比如Math，Arrays,Collections

单例设计模式

• 就是采取一定的方法保证整个软件系统中，某个类只存在一个对象

1. 私有化类的构造器
2. 声明类的对象(static)
   3.声明public，static的方法，返回类的对象

• 饿汉式单例模式 VS 懒汉式单例模式
• 饿汉式: 好处(线程安全) 坏处(对象加载时间过长，占用内存)
• 懒汉式: 好处(延迟对象的加载，节省内存) 坏处(线程不安全，需要修改代码)
• 举例 java.lang.Runtime

main()方法的使用说明

• main()方法作为程序的入口
• main()方法也是一个普通的静态方法
• main()方法可以作为为我们与控制台交互的一种方式

public class Test {
	
	@org.junit.Test
	public void Test1() {
		
	}

	@org.junit.Test
	public void test1() {
		Person.counity = "China";
		Person p1 = new Person();
		p1.name = "小华";
		p1.age = 10;

		Person p2 = new Person();
		p2.name = "小明";
		p2.age = 20;
		
		p1.counity = "中国";
		
		System.out.println(p2.counity);
		
		p1.eat();
		p1.show();
		
		Person.show();
	}

}

class Person{
	static String counity;
	String name;
	int age;
	
	public void eat() {
		System.out.println("eat");
	}
	
	// 静态方法
	public static void show() {
		System.out.println("show");
	}
}

Static练习

public class Test {
	public static void main(String[] args) {
		
		Circle c1 = new Circle(1.5);
		Circle c2 = new Circle(2.5);
		System.out.println(c1.findArea());
		System.out.println(c2.findArea());
		System.out.println(c2.getId());
		System.out.println(Circle.getTotal());
		
	}
}

class Circle{
	private int id;
	private double radius;
	
	private static int total = 0;
	private static int init = 1001;
	
	public Circle(){
		total++;
		id = init++;
	}
	
	public Circle(double radius){
		this();
		this.radius = radius;
	}
	
	public double findArea() {
		return Math.PI * radius * radius;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public double getRadius() {
		return radius;
	}

	public void setRadius(double radius) {
		this.radius = radius;
	}

	public static int getTotal() {
		return total;
	}
	
	
	
}

饿汉式单例模式

// 单例设计模式
public class Singleton1 {
	public static void main(String[] args) {
		Bank bank1 = Bank.getInstance();
		Bank bank2 = Bank.getInstance();
		System.out.println(bank1);
		System.out.println(bank2);
	}
}
 // 饿汉式单例模式
class Bank{
	// 1.始于话类的构造器(是为了避免在类的外部造对象)
	private Bank() {
	}
	
	// 2.在内部创建类的对象
	// 4.要求此对像也是static的，因为static方法里不能调用非静态属性
	private static Bank instance = new Bank();
	
	// 3.提供公共的放，返回类的对象
	public static Bank getInstance() {
		return instance;
	}
}

懒汉式单例模式

// 单例模式
public class Singleton2 {
	public static void main(String[] args) {
		Order order1 = Order.getInstance();
		Order order2 = Order.getInstance();
		System.out.println(order1);
		System.out.println(order2);
	}
}
// 懒汉式单例模式
class Order{
	// 1.始于话类的构造器(是为了避免在类的外部造对象)
	private Order() {
	}
	
	// 2.声明当前类的对象，没有初始化
	// 4.此对象也必须声明为static
	private static Order instance = null;
	
	// 3.声明public，static的返回当前对象的方法
	public static Order getInstance() {
		if(instance == null ) {
			instance = new Order();
		}
		return instance;
	}
	
}