JAVA基础学习笔记(8)：static关键字、单例模式、main方法、代码块、final关键字

1 static关键字

static是静态的意思，可以用来修饰属性、方法、代码块、内部类

1.1 static修饰变量

1.1.1 静态变量与实例变量

实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。
静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。

1.1.2 静态变量的说明

1.静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
2.静态变量的加载要早于对象的创建
3.由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中

1.1.3 静态变量的使用

public class StaticTest {
	public static void main(String[] args) {
		
		Chinese c1 = new Chinese();
		c1.name = "孔子";
		c1.age = 100;
		c1.location = "ZY";
		
		Chinese c2 = new Chinese();
		System.out.println(c2.location);// ZY
		
		//可以通过直接调用类名的方法来
		Chinese.location = "zhongyuan";
		System.out.println(c1.location);// zhongyuan
	}
}

class Chinese{
	String name;
	int age;
	static String location;
}

1.1.4 静态变量与实例变量的内存解析

1.1.5 静态变量的应用场景

1.属性是可以被多个对象所共享的，不会随着对象的不同而不同的。
2.类中的常量也常常声明为static

1.2 static修饰方法

1.2.1 静态方法与非静态方法

1.随着类的加载而加载，可以通过"类.静态方法"的方式进行调用
2.静态方法中，只能调用静态的方法或属性；非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性

1.2.2 静态方法的说明

1.在静态的方法内，不能使用this关键字、super关键字
2.关于静态属性和静态方法的使用，大家都从生命周期的角度去理解

1.2.3 静态方法的使用

public class StaticTest {
	public static void main(String[] args) {
		
		Chinese c1 = new Chinese();
		c1.name = "孔子";
		c1.age = 100;
		c1.location = "ZY";
		
		Chinese c2 = new Chinese();
		System.out.println(c2.location);// ZY
		
		Chinese.location = "zhongyuan";
		System.out.println(c1.location);// zhongyuan
		
		c2.show();
		Chinese.show();
	}
}

class Chinese{
	String name;
	int age;
	static String location;
	
	public static void show() {
		//无法调用非静态方法或属性
		//System.out.println(age);
		//info1();
		//可以调用静态变量和静态方法，因为生命周期相同
		info2();
		System.out.println(location);
	}
	
	public void info1() {
		System.out.println("info1");
	}
	
	public static void info2() {
		System.out.println("info2");
	}
}

1.2.4 静态方法的应用场景

1.操作静态属性的方法，通常设置为static的
2.工具类中的方法，习惯上声明为static的。 比如：Math、Arrays、Collections

2 单例模式

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。 如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造器的访问权限设置为private，这样，就不能用new操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象， 静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。

2.1 饿汉式

public class SingletonTest1 {
	public static void main(String[] args) {
		Bank bank1 = Bank.getInstance();
		Bank bank2 = Bank.getInstance();
		System.out.println(bank1 == bank2); //true
	}
}

//饿汉式
class Bank{
	
	//1.私有化构造器
	private Bank() {
		
	}
	
	//2.内部创建类的对象
	//4.要求此对象的生命也必须是静态的
	private static Bank instance = new Bank();
	
	//3.提供公共的静态的方法，返回类的对象
	public static Bank getInstance() {
		return instance;
	}
}

2.2 懒汉式

public class SingletonTest2 {
	public static void main(String[] args) {
		Order o1 = Order.getInstance();
		Order o2 = Order.getInstance();
		System.out.println(o1 == o2);//true
	}
}

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;
	}
}

3 main方法

3.1 main方法的说明

由于Java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是 public，又因为Java虚拟机在执行main()方法时不必创建对象，所以该方法必须 是static的，该方法接收一个String类型的数组参数，该数组中保存执行Java命令时传递给所运行的类的参数。
又因为main() 方法是静态的，我们不能直接访问该类中的非静态成员，必须创
建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员，这种情况，我们在之前的例子中多次碰到。
总结：
1.main()方法作为程序的入口
2.main()方法也是一个普通的静态方法
3.main()方法可以作为我们与控制台交互的方式

3.2 eclipse传参使用main方法

public class MainTest {
	public static void main(String[] args) {
		for(int i=0; i<args.length; i++) {
			System.out.println("*******" + args[i]);
		}
	}
}

3.3 命令行使用main方法

将MainTest.java文件放入D:\code中，将其中的导包代码去掉。

4 代码块

4.1 代码块的作用

用来初始化类、对象。只能用static关键字来修饰。

4.2 静态代码块和非静态代码块

• 静态代码块：
  1.内部可以有输出语句
  2.随着类的加载而执行,而且只执行一次
  3.作用：初始化类的信息
  4.如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
  5.静态代码块的执行要优先于非静态代码块的执行
  6.静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构
• 非静态代码块：
  1.内部可以有输出语句
  2.随着对象的创建而执行，每创建一个对象执行一次非静态代码块
  3.作用：可以在创建对象时，对对象的属性等进行初始化
  4.如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
  5.非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法

4.3 代码块的使用

public class BlockTest {
	public static void main(String[] args) {	
		String decs = Person.desc;
		System.out.println(decs);
		Person p1 = new Person();
		Person p2 = new Person();
	}
}

class Person{
	//属性
	String name;
	int age;
	static String desc = "我在学习java";
	
	//构造器
	public Person(){
		
	}
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	//非静态代码块
	{
		System.out.println("hello, block");
	}
	//静态代码块
	static {
		System.out.println("hello, static block!");
		desc = "学习java的同时学习很多其他语言！！";
	}
	
	//方法
	public void eat() {
		System.out.println("吃饭");
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	public static void info() {
		System.out.println("Perosn类中的info方法！！");
	}
} 

4.4 属性赋值的先后顺序

可进行初始化赋值的位置：
①默认初始化
②显式初始化/⑤在代码块中赋值
③构造器中初始化
④有了对象以后，可以通过"对象.属性"或"对象.方法"的方式，进行赋值
执行的先后顺序：① - ② / ⑤ - ③ - ④

5 final关键字

final可以用来修饰的结构：类、方法、变量

5.1 final修饰类、方法、变量

1.final标记的类不能被继承，如：String类、System类、StringBuffer类
2.final标记的方法不能被子类重写，如：Object类中的getClass()
3.final标记的变量(成员变量或局部变量)即称为常量，可以考虑赋值的位置：显式初始化、代码块中初始化、构造器中初始化

5.2 final修饰局部变量

使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。

5.3 全局常量

使用static final修饰的属性即全局常量

本节练习

ex1

例：一个圆类的测试程序，使用静态变量init来生成每个圆的编号，使用静态变量total来生成圆的总个数。使用静态方法getTotal来查看圆的总个数。

public class CircleTest {
	public static void main(String[] args) {
		
		Circle c1 = new Circle();
		Circle c2 = new Circle();
		Circle c3 = new Circle(1.0);
		
		System.out.println("c1的id:" + c1.getId());
		System.out.println("c2的id:" + c2.getId());
		System.out.println("c3的id:" + c3.getId());
		System.out.println("圆的总数为： " + c1.getTotal() );
	}

}

class Circle{
	
	private double radius;
	private int id;
	
	private static int total;
	private static int init = 1001;
	
	public Circle(){
		id = init++;
		total++;
	}
	
	public Circle(double radius){
		this();
		this.radius = radius;
		
	}

	public double getRadius() {
		return radius;
	}

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

	public int getId() {
		return id;
	}
	
	public double  findArea() {
		return Math.PI * radius * radius;
	}

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

参考资料：
[1]尚硅谷宋康红java基础教程