Java学习笔记-单例模式等

该博文是传智播客Java基础视频的学习笔记，仅为个人学习笔记，谢谢             

有些类当中，方法都是静态的，不需要创建对象，所以将构造函数私有化。

javadoc的用法：class 前边必须加上public，加上public之后，文件名和类名必须一致，文档能提取出来的只有共有的方法，也只能提取/** */注释的内容。

单例模式：私有化构造函数，通过new在本类中创建一个本类对象，定义一个公有方法，将创建的对象返回

继承：提高代码复用性，让类与类之间之间产生关系，多态产生的前提，Java中支持单继承，不直接支持多继承，但对c++中的多继承机制进行了改良。通过多实现的方式来体现。Java中支持多重继承，如：A extends B , B extends C ... ...，所以，要使用一个继承体系时，查看该体系的顶层类，了解基本功能，然后，创建最底层的子类对象，去使用功能 。

当本类的成员和局部变量同名，用this区分。当子父类中的成员变量同名时用super区分父类

子父类中成员变量的特点：

public class ExtendsDemo {
	public static void main(String[] args) {
		Zi z = new Zi();
		z.show();
	}
}
class Fu{
	int num = 5; 
	// 如果将该处的num设为private，
	// 则下边的super.num会提示The field Fu.num is not visible 
	// 即，子类不能直接访问父类中的私有成员
}
class Zi extends Fu{
	int num = 4;
	void show(){
		System.out.println(this.num+"..."+super.num);// 4...5  
	}
}

子父类中成员函数的特点--覆盖（也称重写、覆写，override）：子父类中出现一模一样的情况，会执行子类的函数。重载是overload

覆盖注意事项：子类方法覆盖父类方法时，子类权限必须要大于等于父类的权限，否则会提示子类中的 方法无法覆盖父类中的方法（Cannot reduce the visibility of the inherited method from Fu）。

如果父类中的方法为private，那么就谈不上覆盖了，覆盖指的是，父类有一个方法可以用，但是子类不用，而是自己写一个出来把父类的方法覆盖掉，如果父类的某个方法为private，那么，虽然子类中定义了相同的方法不会出错，但只能叫做子类自己定义一个方法来用

静态只能覆盖静态，也只能被静态覆盖。

什么时候使用覆盖操作？

当对一个类进行子类扩展，子类需要保留父类的功能声明，但是要定义子类中该功能的特有内容时，就可以使用覆盖操作完成

子父类中构造函数的特点：

在子类所有的构造函数中，如果不显示调用父类构造函数，第一行都有一个默认的隐式语句，super();调用父类中空参数的构造函数

public class ExtendsDemo {
	public static void main(String[] args) {
		Zi z1 = new Zi();// 执行结果是 fu zi
		Zi z2 = new Zi(3);// 执行结果是 fu zi3
	}
}
class Fu{
	Fu(){
		// 如果将该构造函数改为下列构造函数，则需在zi()函数第一行显示调用super（int），
		// 否则会报错，因为，定义了有参构造函数，默认构造函数就没有了
		// zi()函数第一行中却有默认的super（）
		System.out.println("fu");
	}
//	Fu(int x){
//		System.out.println("fu"+x);
//	}
}
class Zi extends Fu{
	Zi(){
		System.out.println("zi");
	}
	Zi(int x){
        //该处也是默认的调用super（）
		System.out.println("zi"+x);
	}
}

因为子类继承了父类的内容，而父类会在构造函数中进行初始化，所以子类在使用父类的内容时，应该走父类的构造函数进行相同的初始化操作，即在子类的构造函数中默认加入了super()语句。

如果父类中定义了非空参数的构造函数，则子类构造函数中必须要在第一行用super语句明确调用父类中的某个构造函数。

如果子类构造函数中使用了this调用了本类的构造函数，那么super就没有了，因为this和super语句都只能放在函数中的第一行，但是子类中一定有一个构造函数调用父类的构造函数。

子类成员变量的初始化问题：

子类中通过super初始化父类的内容时，子类成员变量只是默认初始化，比如int类型的成员变量值为0，并未显示初始化，等super()父类初始化完毕后，才进行子类成员变量的显示初始化。

public class InitializationDemo {
	public static void main(String[] args) {
		Zi z = new Zi();  // zi...show...0
		z.show();  // zi...show...8
	}
}
class Fu{
	int num = 3;
	Fu(){
		show();
	}
	void show(){
		System.out.println("fu...show...");
	}
}
class Zi extends Fu{
	int num = 8;
	Zi(){
		super(); // 隐式的super()语句
		System.out.println("zi...ini..."+num);
		//此处super()语句执行完，父类的初始化完成，开始子类的成员变量的显示初始化
		//所以结果为zi...ini...8
	}
	void show(){
		System.out.println("zi...show..."+num);
	}
}

一个对象的实例化过程：

Person p = new Person();

1、JVM会读取指定路径下的Person.class文件，并加载进内存，同时会加载Person的父类（假设Person有父类）

2、在堆内存中开辟空间，分配地址

3、在堆内存的对象空间中对对象的属性进行默认初始化

4、调用对应的构造函数进行初始化

5、在构造函数中，第一行会先调用父类的构造函数进行初始化

6、父类初始化完毕后，再对本类的属性进行显示初始化

7、再进行本类构造函数的特定初始化

8、所有初始化完毕后，将地址赋给引用变量 p

final关键字：

final可以修饰类、方法和变量

final修饰的类不可以被继承

final修饰的方法不可以被覆盖

final修饰的变量是一个常量，只能被赋值一次

内部类只能访问被final修饰的局部变量

应用场景：

1、封装被打破是继承的弊端之一，可以考虑使用final修饰类避免，如：final class Fu

2、如果Fu类中，只有一部分方法不能被覆盖，则只需用final修饰不能被覆盖的方法

3、如果一个变量是固定值，就可以用final修饰这个变量为一个常量，名称规范：所有字母大写，单词间用下划线连接，常量只能赋值一次

final int x;语句会报错，The blank final field x may not have been initialized，因为final修饰的变量需要显示初始化

 

抽象：

抽象类特点：

1、方法只有声明没有具体实现，该方法就是抽象方法，需要被abstract修饰，如abstract void show();

抽象方法必须定义在抽象类中，抽象类也是用abstract修饰 abstract class Demo{}

2、抽象类不可以被实例化

3、抽象类的子类必须覆盖所有抽象方法之后，才能创建对象，否则这个子类还是一个抽象类

抽象类中也有构造函数，用于给子类对象进行初始化

抽象类中也可以不定义抽象方法，目的就是不让该类创建对象，但是这种情况很少见，AWT的适配器对象就是这种类，通常这个类中的方法有方法体，但是却没有内容

abstract关键字不可以和private、static、final进行组合

接口：当一个抽象类中的方法都是抽象的时候，可以将这个类用另一种形式来体现。

接口的出现将Java中的多继承通过另一种方式体现出来，即多实现

格式：interface{}

接口中的成员修饰符是固定的，接口中的成员都是public的

成员常量：public static final

成员函数：public abstract

由于接口中的修饰符格式是固定的，所以，接口中成员的修饰符public、 static 、final 和abstract都可以省略

一个类在继承某个类的同时，还能实现多个接口，接口与接口之间是继承关系，而且接口之间可以多继承，原因就是没有方法体，不会出现执行内容的不确定性。

多态：

在代码中的体现就是，父类或者接口的引用指向子类对象，提高代码的扩展性

多态的前提：

1、必须存在继承或实现关系

2、需要存在覆盖

多态使用过程中，涉及 instanceof 的使用，instanceof 只能用于引用数据类型的判断

多态的特点：

成员函数：编译时，要看引用变量所属的类中是否有所调用的成员，有则编译通过，没有，则编译失败。运行时，要查看对象所属的类

成员变量：编译时，要看引用变量所属的类中是否有所调用的成员，有则编译通过，没有，则编译失败。运行时，只看引用变量所属的类

静态函数：编译和运行都参考引用变量所属的类

内部类：

内部类可以直接访问外部类中的成员，包括私有成员

外部类要访问内部类中的成员，必须要建立内部类对象

内部类可以被成员修饰符所修饰

内部类的使用场景：

假设Inner为Outer的内部类，则在其他类中创建Inner对象的写法为：

Outer.Inner in = new Outer().new Inner();

如果内部类是静态的，相当于一个外部类

Outer.Inner in = new Outer.Inner();

如果内部类是静态的，内部类的成员也是静态的，则直接使用：

Outer.Inner.show();

如果一个内部类中有了静态成员，该内部类必须用静态修饰

public class InnerClassDemo {
	public static void main(String[] args) {
		new Outer().method();
	}
}
class Outer{
	int num = 3;
	class Inner{
		int num = 4;
		void show() {
			int num = 5;
			System.out.println(num); //5
			System.out.println(this.num); // 4
			System.out.println(Outer.this.num); // 3
		}
	}
	void method() {
		new Inner().show();
	}
}

内部类也可以放在局部位置上

public class InnerClassDemo {
	public static void main(String[] args) {
		new Outer().method();
	}
}
class Outer{
	int num = 3;
	void method() {
		class Inner{
			int num = 4;
			void show() {
				System.out.println(num); //4
			}
		}
		new Inner().show();
	}
}

从内部类中访问局部变量x，需要被声明为final类型：

class Outer{
	int num = 3;
	void method() {
		final int x = 9;//从内部类中访问局部变量x，需要被声明为final类型
		class Inner{
			int num = 4;
			void show() {
				System.out.println(x);
			}
		}
		new Inner().show();
	}
}

因为Inner虽然是在局部位置上，但它是一个类，是可以创建对象的，method方法执行完之后，非final修饰的局部变量x就消失了，但是创建出来的Inner对象可能还在被某个变量所指向，这时候就会导致inner对象需要访问局部变量x时访问不到，所以就需要用final修饰x

匿名内部类：

使用的前提：内部类必须继承或实现一个外部类或者接口

public class InnerClassDemo {
	public static void main(String[] args) {
		new Outer().method();
	}
}
abstract class Demo{
	abstract void function();
}
class Outer{
	/*class Inner extends Demo{
		void function() {
			System.out.println("function");
		}
	}*/
	void method() {
//		new Inner().function();
		new Demo(){
			void function() {
				System.out.println("function");
			}
		}.function();
	}
}

匿名内部类的使用场景：

当函数的参数是接口类型，并且接口中的方法不超过三个时，可以用匿名内部类作为实际参数传递

匿名内部类使用注意事项：

public class InnerClassDemo1 {
	public static void main(String[] args) {
		new Outer().method();
	}
}
class Outer{
	void method(){
		new Object(){
			void show(){
				System.out.println("show");
			}
		}.show();
		// 以下方式编译失败，因为匿名内部类这个子类对象被向上转型为了Object类型，
		// 这样就不能再使用子类的特有方法了，参考多态
		/*Object obj = new Object(){
			void show(){
				System.out.println("show");
			}
		};
		obj.show();*/
	}
}

对象的初始化过程：

一个对象的实例化过程：

Person p = new Person();

1、JVM会读取指定路径下的Person.class文件，并加载进内存，同时会加载Person的父类（假设Person有父类）

2、在堆内存中开辟空间，分配地址

3、在堆内存的对象空间中对对象的属性进行默认初始化

4、调用对应的构造函数进行初始化

5、在构造函数中，第一行会先调用父类的构造函数进行初始化

6、父类初始化完毕后，再对本类的属性进行显示初始化

7、显示初始化完成之后，是构造代码块初始化

8、再进行本类构造函数的特定初始化

9、所有初始化完毕后，将地址赋给引用变量 p