JAVA基础课程(第十二天)

JAVA基础课程

第十二天

static

（1）static:静态的

（2）可以修饰：属性，方法，代码块，内部类

（3）

修饰属性：修饰了的叫静态变量 vs 未修饰的叫非静态变量（实例变量）

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

​ 静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时。会导致其他对象调用此静态变量是修改过的。

说明：①静态变量随着类的加载而加载，可以通过“类.静态变量”的方式调用

​ ②静态变量的加载要早于对象的创建

​ ③由于类只会加载一次，这静态变量在内存中也只会存在一份，存在方法区的静态域中

修饰方法：静态方法

​ ①随着类的加载而加载，可以通过“类.静态方法”的方式调用

​ ②静态方法只能调用静态方法和静态属性，

​ 非静态方法可以调用静态方法和静态属性也乐意调用非静态方法和非静态属性

​ ③静态方法不能是使用this和super关键字

​ ④关于静态方法和静态变量的使用，从生命周期的角度去考虑

​ （4）代码示例：

/**
 * @author PitterWang
 * @create 2020/4/29
 * @since 1.0.0
 */
public class StaticTest {

	public static int a = 12;

	public static void runing(){
		System.out.println("Runing-------------");
	}

	public static void main(String[] args) {
		System.out.println(StaticTest.a);
		StaticTest.runing();
	}
}

单例模式

​ （1）设计模式：在大量的实践中总结和理论化之后优选的代码结构，编码风格，已经解决问题的思考方法。

创建型：5种：工厂模式，抽象工厂模式，单例模式，建造者模式，原型模式

结构型：7种：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式

行为型：11种：策略模式，模板方法模式，观察者模式，迭代子模式，责任链模式，命令模式，备忘录模式，状态模式，访问者模式，中介者模式，解释器模式

​ （2）单例模式，就是采取一定的方法，包装整个软件系统中，对某个类只能存在一个对象实例。并且改类只提供一个取其对象实例的方法

​ 懒汉式：好处，延迟对象创建，现在由于没有学线程，所以写的都是线程不安全的

​ 饿汉式：是线程安全的，对象加载时间长

​ （3）引用场景：数据库连接池等

​ （4）代码实现：

package com.test.shejimoshi;

/**
 * 〈懒汉式〉 --线程不安全的
 *
 * @author PitterWang
 * @create 2020/4/29
 * @since 1.0.0
 */
public class SingletonLazy {

	private static SingletonLazy singletonLazy;
	private SingletonLazy(){
	}

	public SingletonLazy getInstance(){
		if(singletonLazy == null){
			singletonLazy = new SingletonLazy();
		}
		return singletonLazy;
	}
}

package com.test.shejimoshi;

/**
 * 〈饿汉式〉
 *
 * @author PitterWang
 * @create 2020/4/29
 * @since 1.0.0
 */
public class SingletonHungry {
	private static SingletonHungry singletonHungry = new SingletonHungry();

	private SingletonHungry(){}

	public SingletonHungry getInstance(){
		return singletonHungry;
	}
}

main()方法说明

	public static void main(String[] args) {
	}

（1）main作为程序的主入口

（2）也可以看作一个普通的静态方法

（3）也可以做完我们与控制台交互的方式

代码块

（1）作用:用来初始化类、对象

（2）只能用static修饰

（3）静态代码块和非静态代码块

​ 静态代码块：

​ ①内部可以有输出语句

​ ②随着类的加载而执行，而且只执行一次

​ ③初始化类信息

​ ④如果定义多个静态代码块，按照声明顺序执行

​ ⑤静态优先于非静态代码块执行

​ ⑥只能调用静态属性和静态方法，不能调用非静态的结构

​ 非静态代码块

​ ①内部可以有输出语句

​ ②随着对象的创建而执行

​ ③没执行一个对象，就执行一次非静态代码块

​ ④创建对象时，对对象的属性进行初始化

​ ⑤如果定义多个非静态代码块，按照声明顺序执行

​ ⑥非静态代码块可以调用静态方法和属性，也可以调用非静态方法和属性

package com.test.course;

/**
 * 〈代码块〉
 *
 * 结果：
 * 父类静态代码块
 * 子类静态代码块
 * 父类非静态代码块
 * 父类无参构造方法
 * 子类非静态代码块
 * 子类无参构造方法
 * 
 * 由父及子，静态先行
 * @author PitterWang
 * @create 2020/4/29
 * @since 1.0.0
 */
public class CodeBlockTest {
	public CodeBlockTest(){
		System.out.println("父类无参构造方法");
	}
	{
		System.out.println("父类非静态代码块");
	}
	static {
		System.out.println("父类静态代码块");
	}


	public static void main(String[] args) {
		CodeBlock codeBlockTest = new CodeBlock();
	}
}

class CodeBlock extends CodeBlockTest{

	public CodeBlock(){
		System.out.println("子类无参构造方法");
	}
	{
		System.out.println("子类非静态代码块");
	}
	static {
		System.out.println("子类静态代码块");
	}
}

再谈属性赋值的先后顺序

①默认初始值

②显式初始值

③构造器中初始值

④通过对象.属性的方法或者对象.方法的方式去初始值

⑤代码块中初始值

①——》②/⑤——》③——》④

final

（1）final：最终的

（2）可以修饰：变量，方法，类，

（3） final修饰类：不能被其他类继承

​ final修饰方法：不可以被重写

​ final修饰变量：“变量”就变成常量。

①修饰属性：显式初始化，代码块中初始化，构造器中初始化

②修饰局部变量：修饰形参是，表明此形参是一个常量，当调用此方法时，给常量形参赋一个实参。一旦定义了，就只能在方法体内使用，不能重写赋值。

package com.test.course;

/**
 * 〈final〉
 *
 * @author PitterWang
 * @create 2020/4/29
 * @since 1.0.0
 */
public class FinalTest {

	public final int a = 12;

	public final void test(){
		System.out.println("11111111111");
	}

	public void test(final int a){
		//a = 12;只能使用，不能修改
		System.out.println(a);
	}
}