Java入门7.1---关键字static、final、抽象类、接口

一、关键字：static

static：可以用来修饰属性、方法、*代码块（或初始化块）、*内部类

1.static修饰属性（类变量）

1. 由类创建的所有的对象，都共用这一个属性；
2. 当其中一个对象对此属性进行修改，会导致其他对象对此属性的一个调用。 VS 实例变量（非static修饰的属性，各个对象各自拥有一套副本）
3. 类变量随着类的加载而加载的，而且独一份。
4. 静态变量可以直接通过“类.类变量”的形式来调用。（实例变量：随着对象的创建而被加载的，所以静态变量加载时间要早于实例变量。）
5. 类变量的加载要早于对象。所以当有对象以后，可以“对象.类变量”调用，但是“类.实例变量”是不行的。
6. 类变量存在于静态域中。

举例：

2.static修饰方法（类方法）

1. 随着类的加载而加载，在内存中也是独一份；
2. 可以直接通过“类.类方法”的方式调用。
3. 在静态方法内部，可以调用静态的属性或静态的方法，而不能调用非静态的属性或方法。反之，非静态的方法是可以调用静态的属性或静态方法。（原因：生命周期不同）
4. 静态的方法内是不可以有this或super关键字的！！！（在调用当前static方法时，可能没有生成对象，不能用this.方法）

注：静态的结构（static的属性、方法、代码块、内部类）的生命周期要早于非静态的结构，同时被回收也要晚于非静态的结构。

3.设计模式及单例模式的饿汉式和懒汉式

3.1 设计模式

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

1. 单例的设计模式：使得一个类只能够创建一个对象。

3.2 单例模式---饿汉式（线程安全）

public class TestSingleton{
	public static void main(String[] agrs){
		Singleton s1 = Singleton.getInstance();
		Singleton s2 = Singleton.getInstance();
		System.out.println(s1 == s2);
	}
}

class Singleton{
	// 1.私有化构造器，使得在类的外部不能够调用此构造器
	private Singleton(){
	
	}
	// 2.在类的内部创建一个类的实例
	private static Singleton instance = new Singleton();
	// 3.私有化此对象，通过公共的方法来调用
	// 4.此公共的方法，只能通过类来调用，因此设置为static，同时类的实例也必须为static声明的
	public static Singleton getInstance(){
		return instance;
	}
	
}

Java.lang包下面的runtime类用的是饿汉式单例模式

3.3 单例模式---懒汉式（线程不安全）

用的时候再创建

// 2.懒汉式
public class TestSingleton{
	public static void main(String[] agrs){
		Singleton s1 = Singleton.getInstance();
		Singleton s2 = Singleton.getInstance();
		System.out.println(s1 == s2); // true
	}
}

class Singleton{
	// 1.私有化构造器，使得在类的外部不能够调用此构造器
	private Singleton(){
	
	}
	// 2.在类的内部创建一个类的实例
	private static Singleton instance = null;
	// 3.此公共的方法，只能通过类来调用，因此设置为static，同时类的实例也必须为static声明的
	public static Singleton getInstance(){
		if (instance == null){
			instance = new Singleton();
		}
		return instance;
}　　

4.main方法

 

5.类的成员之四：初始化块

非静态代码块：没有static修饰的代码块	静态代码块：用static修饰的代码块

关于属性赋值的操作：

1. 默认的初始化；
2. 显示的初始化或代码块初始化（此处两个结构按照顺序执行）；
3. 构造器中；
4. 通过方法对对象的相应属性进行修改。

初始化块：

1. 代码块如果有修饰的话，只能使用static；
2. 分类： 

静态代码块	非静态代码块
里面可以有输出语句 随着类的加载而加载，而且只能被加载一次 多个静态代码块之间按照顺序结构执行 静态代码块执行要早于非静态代码块执行 静态代码块中执行执行静态的结构（类属性、类方法）	可以对类的属性（静态的、非静态的）进行初始化操作，同时也可以调用本类声明的方法（静态的、非静态的） 里面可以有输出语句 一个类中可以有多个非静态的代码块，多个代码块之间安装顺序结构执行 每创建一个类的对象， 非静态代码块就加载一次 非静态代码块的执行要早于构造器

二、关键字：final

在Java中声明类、属性和方法时，可使用关键字final来修饰，表示“最终”。

1.final修饰的类不能被继承

提高安全性，提高程序的可读性。如：String类、System类、StringBuffer类

2.final修饰的方法不能被子类重写

如：Object类中的getClass()

3.final修饰的变量（成员变量或局部变量）称为常量

习惯上，常量用大写字符表示，且只能被赋值一次。此常量在哪里赋值：

1. 此常量不能使用默认初始化；
2. 可以显示的赋值、代码块、构造器，不能在方法中赋值。

变量用static final修饰，为全局常量。

与finally finalize()区别

三、抽象类

abstract：抽象的，可以用来修饰类、方法

1.abstract修饰类 ，抽象类

（1）不可被实例化

（2）抽象类有构造器（凡是抽象类，都有构造器）【保证在创建类的实例时，有实例化的过程】

（3）抽象方法所在的类，一定是抽象类

（4）抽象类中可以没有抽象方法

2.abstract修饰方法，抽象方法

（1）格式：只有方法的声明，没有方法的实现。以分号结束，如，public abstract void eat();

（2）抽象方法只保留方法的功能，而具体的执行，交给继承抽象类的子类，由子类重写抽象方法

（3）若子类继承抽象类，并重写了所有的抽象方法，则此类是一个“实体类”，即可以实例化

（4）若子类继承抽象类，没有重写所有的抽象方法，意味着此类中仍有抽象方法，则此类必须声明为抽象的

3.abstract不适用的场景

不能用abstract修饰：

1. 属性
2. 构造器：构造器不能被重写
3. private方法：子类不能覆盖（或重写）声明为private的方法
4. 静态方法：静态方法意味着可以通过类来直接调用，当声明为抽象时，又没有方法体。
5. final方法：final与abstract矛盾

4.模板方法设计模式（TemplateMethod）

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上回保留抽象类的行为方式。

解决的问题：

1. 当功能内部一部分实现是确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。
2. 编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式。

四、接口

　　有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。接口是与类并行的一个概念。

1. 接口是抽象方法和常量值的定义的集合。
2. 从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量（所有的常量都用public static final修饰）和方法的定义（抽象方法：所有的都用public abstract修饰），而没有变量和方法的实现。
3. 接口是没有构造器的
4. 接口定义的就是一种功能，此功能可以被类所实现（implements），比如，class CC implements AA
5. 实现接口的类，必须要重写其中的所有抽象方法，方可实例化。若没有重写所有的抽象方法，则此类仍为一个抽象类。
6. 类可以实现多个接口-------Java中的继承是单继承的
7. 接口与接口直接也是继承的关系，而且可以实现多继承。

实现接口类：class Subclass implements InterfaceA{}