static关键词
static关键字：可以修饰属性、方法、代码块、内部类。
一、使用static修饰属性：静态变量（或类变量）
1. 属性，按是否使用static修饰，又分为：静态属性 vs 非静态属性(实例变量)
实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。
静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。
2. static修饰属性的其他说明：
① 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
② 静态变量的加载要早于对象的创建。
③ 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。
④ 类变量 实例变量
类 yes no
对象 yes yes
二、用static修饰方法：静态方法
① 随着类的加载而加载，可以通过"类.静态方法"的方式进行调用
② 静态方法 非静态方法
类 yes no
对象 yes yes
③ 静态方法中，只能调用静态的方法或属性
非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性
三、 static注意点：
5.1 在静态的方法内，不能使用this关键字、super关键字
5.2 关于静态属性和静态方法的使用，大家都从生命周期的角度去理解。
四、 开发中，如何确定一个属性是否要声明为static的？
> 属性是可以被多个对象所共享的，不会随着对象的不同而不同的。
> 类中的常量也常常声明为static
开发中，如何确定一个方法是否要声明为static的？
> 操作静态属性的方法，通常设置为static的
> 工具类中的方法，习惯上声明为static的。 比如：Math、Arrays、Collections
package com.atguigu.java2;
/*
* 单例设计模式：
* 1. 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。
*
* 2. 如何实现？
* 饿汉式 vs 懒汉式
*
* 3. 区分饿汉式 和 懒汉式
* 饿汉式：
* 坏处：对象加载时间过长。
* 好处：饿汉式是线程安全的
*
* 懒汉式：好处：延迟对象的创建。
* 目前的写法坏处：线程不安全。--->到多线程内容时，再修改
*
*
*/
public class SingletonTest1 {
public static void main(String[] args) {
// Bank bank1 = new Bank();
// Bank bank2 = new Bank();
Bank bank1 = Bank.getInstance();
Bank bank2 = Bank.getInstance();
System.out.println(bank1 == bank2);
}
}
//饿汉式
class Bank{
//1.私有化类的构造器
private Bank(){
}
//2.内部创建类的对象
//4.要求此对象也必须声明为静态的
private static Bank instance = new Bank();
//3.提供公共的静态的方法，返回类的对象
public static Bank getInstance(){
return instance;
}
}
/*
* 单例模式的懒汉式实现
*
*/
public class SingletonTest2 {
public static void main(String[] args) {
Order order1 = Order.getInstance();
Order order2 = Order.getInstance();
System.out.println(order1 == 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;
}
}
main方法是静态的
main()方法的使用说明：
1. main()方法作为程序的入口
2. main()方法也是一个普通的静态方法
3. main()方法可以作为我们与控制台交互的方式。（之前：使用Scanner）
public static void main(String[] args) {}
/*
public : 被jvm调用，访问权限足够大。
static : 被jvm调用，不用创建对象，直接类名访问
void : 被jvm调用，不需要给jvm返回值
main : 一个通用的名称，虽然不是关键字，但是被jvm识别
String[] args : 以前用于接收键盘录入的
*/
代码块
类的成员之四：代码块（或初始化块）
一、代码块的作用：用来初始化类、对象
二、代码块如果有修饰的话，只能使用static.
三、分类：静态代码块 vs 非静态代码块
四、静态代码块
>内部可以有输出语句
>随着类的加载而执行,而且只执行一次
>作用：初始化类的信息
>如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
>静态代码块的执行要优先于非静态代码块的执行
>静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构
五、 非静态代码块
>内部可以有输出语句
>随着对象的创建而执行
>每创建一个对象，就执行一次非静态代码块
>作用：可以在创建对象时，对对象的属性等进行初始化
>如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
>非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法
代码块：使用 {} 括起来的代码被称为代码块，根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。
一、局部代码块：在方法中出现；限定变量生命周期，及早释放，提高内存利用率
二、构造代码块：在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行。
执行顺序：局部代码块——>静态代码块（static）——>构造代码块——>构造方法
如果代码块中包含static，无论是在父类还是子类中，都先执行静态代码块。
静态代码块只执行一次。
三、静态代码块：在类中方法外出现，加了static修饰 在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且值执行一次。
对属性可以赋值的位置：
①默认初始化
②显式初始化/⑤在代码块中赋值
③构造器中初始化
④有了对象以后，可以通过"对象.属性"或"对象.方法"的方式，进行赋值
执行的先后顺序：① - ② / ⑤ - ③ - ④
final关键字
final 可以用来修饰: 类、方法、变量。
-
final关键字修饰类：类不能被其他类继承。
比如：String类、System类、StringBuffer类。
- final关键字修饰成员变量，成员变量变成了一个常量，只能赋值一次，不能被修改。 可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化
- final修饰局部变量，在方法内部（基本数据类型），值不能修改。如果修饰引用数据类型，引用的地址值不能发生改变（例：final Student s = new Studen(); ）。
- final关键字修饰方法，方法不能被重写。比如：Object类中getClass();
- final初始化时机：在构造对象完成之前。
- static final 用来修饰属性：全局常量
抽象类
一、抽象类格式：
abstract class 类名{}
/*
用abstract关键字来修饰一个类，这个类叫做抽象类。
用abstract来修饰一个方法，该方法叫做抽象方法。
public abstract void example();
*/
二、注意事项：
1.抽象类不一定有抽象方法，包含抽象方法的类一定是抽象类。
2.抽象类不能实例化，但是可以通过子类继承，通过子类实例化。抽象类的子类必须重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍为抽象类。
3.abstract 不能用来修饰 final 、final的类、private（私有方法）、static（静态方法）
4.abstract不能用来修饰变量、代码块、构造器；
public class AbstractTest2 {
public static void main(String args[]) {
A a = new B();
a.m1();
a.m2();
}
}
abstract class A {
abstract void m1();
public void m2() {
System.out.println("A类中定义的m2方法");
} }
class B extends A {
void m1() {
System.out.println("B类中定义的m1方法");
}
}
//输出：B类中定义的m1方法
//A类中定义的m2方法
问题1：为什么抽象类不可以使用final关键字声明？
因为抽象类得通过子类继承，子类实例化，而final关键字就指定了类不能被继承。
问题2：一个抽象类中可以定义构造器吗？
可以
三、抽象类的匿名子类
接口(interface)
一、接口（interface）格式：
interface 接口名{}
二、注意事项：
1.类实现接口用 implements
class 类名 implements 接口名{}
2.接口不能被实例化。
2.1 接口多态：由具体子类进行实例化
2.2接口的子类：要么是抽象类。要么是具体的子类，但是必须要重写接口中所有的抽象类。
总结： 1.开发中最常见的是接口多态
2.抽象多态
3.具体类
三、接口中成员
1.成员变量：只能是常量，而且是静态的。且有默认修饰符 public static final，如果在定义变量时没有，会自动补上。
2.构造方法：接口中无构造方法。
3.成员方法：接口中只能是抽象方法，无方法体。有默认值： public abstract
四、类与接口的关系
1.类与类：继承关系。只能单继承。不能一次性继承多个，但可以多层继承。
2.类与接口：类可以单个实现接口，也可以一次性实现多个接口。可以在继承一个类时，实现多个接口，每个类都默认继承Object类。
3.接口与接口：无实现关系，只有继承关系。可单继承，也可一次性继承多个。
内部类
四、成员内部类作为类的成员的角色：
实例化静态的成员内部类 内部类：A 外部类：B
B.A 具体名 = new B.A（）；
实例化非静态的成员内部类
B.A 具体名 = B.new A（）；
2.