一、 格式：修饰符 类名（参数签名）{}
- 1.构造方法名称必须和类名相同，包括大小写，构造器没有返回值，但也不能写void，不能写return
- 2.用new调用，且对象一旦建立，构造方法就运行且只运行一次
- 3.类一定有构造器，就算是自己没声明构造器，java编译器也会自动插入一个默认的无参构造器，默认构造器是看不到的，但是如果自己声明构造器了，java就不会给你插入了。所以说，如果只声明了一个有参的构造器，如果调用这个对象的无参构造方法，就会报错的。
- 4.构造器是可以重载的，一个类中可以声明多的构造器，而且方法名都相同，就像树苗和大树，都是树。
- 5.构造器是不可以继承的，子类继承父类，所以子类构造器默认调用父类的无参构造器，子类构造器是一定要调用父类的构造器的。子类会默认有一个super()来进行调用，而且一定必须得在第一行。如果父类没有无参构造器，则必须使用super(参数)来调用父类的有参构造器。所以为什么子类一定要调用父类的构造器，因为父类的数据可以直接获取。
二、 构造方法的作用：
- 1.为了初始化成员属性，而不是初始化对象，初始化对象是通过new关键字实现的
- 2.通过new调用构造方法初始化对象，编译时根据参数签名来检查构造函数，称为静态联编和编译多态（参数签名：参数的类型，参数个数和参数顺序）
- 3.创建子类对象会调用父类构造方法但不会创建父类对象，只是调用父类构造方法初始化父类成员属性。
三、类的加载顺序
静态先行 > 构造块 > 构造方法
class Children {
public Children() {
System.out.println("构造方法111");
}
{
System.out.println("构造块222");
}
static {
System.out.println("静态代码块333");
}
}
public class Demo01 {
{
System.out.println("构造方法444");
}
static {
System.out.println("静态代码块555");
}
public Demo01() {
System.out.println("构造方法666");
}
public static void main(String[] args) {
System.out.println("美丽分割线000");
new Children();
new Children();
new Demo01();
}
}
运行结果
1、类初始化和实例化对象过程
class Son extends Father {
private int i = test();
private static int j = method();
public Son() {
System.out.println("6");
}
{
System.out.println("7");
}
static {
System.out.println("8");
}
public int test() {
System.out.println("9");
return 1;
}
public static int method() {
System.out.println("10");
return 1;
}
public static void main(String[] args) {
}
}
public class Father {
private int i = test();
private static int j = method();
static {
System.out.println("1");
}
Father() {
System.out.println("2");
}
{
System.out.println("3");
}
public int test() {
System.out.println("4");
return 1;
}
public static int method() {
System.out.println("5");
return 1;
}
}
如上来看，main方法在son中，启动后会加载Son类，因为Son类是Father的子类，所以先加载Father，父类要先初始化，静态static的随着类的加载进行加载，所以父类自上而下执行静态的方法和静态代码块，会调用method方法，输出5，1子类同理,所以执行结果是5、1、10、8
class Son extends Father {
private int i = test();
private static int j = method();
public Son() {
System.out.println("6");
}
{
System.out.println("7");
}
static {
System.out.println("8");
}
public int test() {
System.out.println("9");
return 1;
}
public static int method() {
System.out.println("10");
return 1;
}
public static void main(String[] args) {
Son son1 = new Son();
System.out.println("==================");
Son son2 = new Son();
}
}
public class Father {
private int i = test();
private static int j = method();
static {
System.out.println("1");
}
Father() {
System.out.println("2");
}
{
System.out.println("3");
}
public int test() {
System.out.println("4");
return 1;
}
public static int method() {
System.out.println("5");
return 1;
}
}
首先如上面加载类，执行的是5、1、10、8，然后开始创建对象，Son实例开始初始化，实例初始化包含非静态实例变量显示赋值代码、非静态代码块、构造器，构造器是最后执行的，另外按照前后顺序，所以先是父类执行test方法，而这里要注意了，子类中也有test方法，实际上子类重写了父类的test方法，所以要执行子类的test，所以就是9、3、2。在执行子类的就是9、7、6。而接下来有创建了一个对象，所以又是9、3、2、9、7、6。所以最终是5、1、10、8、9、3、2、9、7、6、9、3、2、9、8、7。而为什么子类重写了test方法，而没有重写method方法呢，因为三种情况，是不能被重写的，static、final、private。
四、简单计算
public class Father {
public static void main(String[] args) {
int i = 1;
String str = "hello";
Integer num = 2;
int[] arr = {1, 2, 3, 4, 5};
MyDate myDate = new MyDate();
change(i, str, num, arr, myDate);
System.out.println(i);//1
System.out.println(str);//hello
System.out.println(num);//2
System.out.println(Arrays.toString(arr));//22345
System.out.println(myDate.a);//11
}
public static void change(int j, String s, Integer n, int[] a, MyDate m) {
j += 1;
s += "world";
n += 1;
a[0] += 1;
m.a += 1;
}
}
class MyDate {
int a = 10;
}
这个题的重点在于基本数据类型和引用类型指向不同。其中实参是引用数据类型，传的是地址，基本数据类型，传的是数据值。特别注意这个题的String的不可变性，还有包装类Integer。
public class Father {
public static void main(String[] args) {
int i = 1;
i = i++;
int j = i++;
int k = (++i + i++ * i);
System.out.println(i);
System.out.println(j);
System.out.println(k);
}
}
打眼一看，肯定是4、2、15啊，问题出在 i=i++，在这里先进行右边的计算，然后再赋值，这个局部变量现在是1，因为i++的“++”是在后边，所以先入栈后自增，先将i=1压入栈中，然后i自增1，局部变量就是2，然后进行“=”的赋值操作，就要把i从栈中取出来，最后i=1。其实结果是4、1、15
五、成员变量和局部变量
public class Father {
static int s;
int i;
int j;
{
int i = 1;
i++;
j++;
s++;
}
public void test(int j) {
j++;
i++;
s++;
}
public static void main(String[] args) {
Father obj1 = new Father();
Father obj2 = new Father();
obj1.test(10);
obj1.test(20);
obj2.test(30);
System.out.println(obj1.i + "," + obj1.j + "," + obj1.s);
System.out.println(obj2.i + "," + obj2.j + "," + obj2.s);
}
}
运行结果
（1）声明的位置
- 局部变量是在方法体{}中、形参、代码块{}中
- 成员变量是在类中的方法外，而成员变量又分类变量和实例变量：类变量是static修饰的，实例无
（2）修饰符
- 局部变量：final
- 成员变量：public、private、protected、final、static、volatile、transient
（3）值存储位置
- 局部变量：栈
- 实例变量：堆
- 类变量：方法区
（4）作用域
- 局部变量：从声明位置到}
- 实例变量：在当前类中“this.”调用（“this.”可以省略，但是访问的就是就近的这个变量了，就有可能是局部变量），在其他类中，“对象名.”来访问。
- 类变量：当前类中“类名.”（“类名.”可以省略，但是访问的就是就近的这个变量了，就有可能是局部变量），在其他类中，“对象名.”或者“类名.”访问
（5）生命周期
- 局部变量：每一个线程，每一次调用执行的都是新的生命周期。
- 实例变量：随着对象的创建而初始化，随着对象回收消亡，每一个对象的实例变量是独立的。
- 类变量：随着对象的初始化而初始化，随着类卸载而消亡，该类的所有对象的类变量是共享的。
要注意，方法在执行的时候会在栈中分配一块空间，比如说在main方法执行的时候，是在栈分配了一块区域，然后实例化obj1，会有一个<init>方法，又会分配一块区域，这时候局部变量int i = 1 也是在栈这块区域的。
六、单例模式
// 饿汉式
public class Singalton01 {
private Singalton01() {
}
public static final Singalton01 INSTANCE = new Singalton01();
}
/**
* @description 饱汉式，在内部类被加载和初始化时，才会创建INSTANCE实例对象
* 静态内部类不会随着外部类的加载和初始化而创建，他是需要单独去初始化的，
* 只有调用getInstance方法时才会创建INSTANCE实例对象，因此是线程安全的
* @author fzq
* @time 2024/5/11 10:27
*/
public class Singalton02 {
private Singalton02() {
}
public static class Inner {
private static Singalton02 INSTANCE = new Singalton02();
}
public Singalton02 getInstance() {
return Inner.INSTANCE;
}
}
/**
* 使用双重检查锁定实现的单例模式。
* 这种方式在多线程环境下会保证安全性，在单线程环境下避免了同步带来的性能影响。
*/
public class Singalton03 {
private Singalton03() {
}
public static Singalton03 INSTANCE = null;
/**
* 获取单例对象的方法。
* 采用双重检查锁定机制，确保在多线程环境下只创建一个实例，
* 同时在单线程环境下避免同步的性能开销。
*/
public static Singalton03 getInstance() {
if (null == INSTANCE) { // 第一层检查，如果实例为null，则进入同步块
synchronized (Singalton03.class) {
if (null == INSTANCE) {
// 第二层检查，因为在第一次创建后，可能会有其他的线程获取到锁，
//进入到这里，再次确认实例是否被创建，避免多线程下的重复创建
INSTANCE = new Singalton03();
}
}
}
return INSTANCE;
}
}
