final关键字
- 修饰变量：关键字final修饰变量，表示这个变量只能被赋值一次，一旦被赋值之后，就不能再更改了，即final修饰变量时，是用来定义常量的，常量名应该全大写。例如如下代码：
final double PI = 3.14;
PI = 24.1; // error: cannot assign a value to variable 'PI'- 修饰方法：可被子类继承，但是不能被子类覆盖
- 修饰类：不需要被继承，（final类的所有方法自动地成为final方法，但是类中域不会自动变成final）
命令行参数
每一个Java应用程序都有一个带String args[ ]参数的main方法，这个参数表明main方法将接收一个字符串数组，也就是命令行参数。例如
public class Test {
public static void main (String[] args) {
System.out.println("1" + args[0]);
System.out.println("2" + args[1]);
System.out.println("3" + args[2]);
}
}
// 编译上述源码后，在终端输入一下指令
java Test hi my world
// 运行结果
1hi
2my
3world无参数的构造器
仅当类没有提供任何构造器的时候，系统才会提供一个默认的不带参数的构造器，如果在编写类的时候，编写了一个构造器，哪怕是很简单的，要想让这个类的用户能够采用new ClassName()的方式构造实例，就必须提供一个默认的不带参数的构造器。
初始化块
- 对象初始化块，第一次构造了类的实例，该初始化块就被会执行；
- 静态初始化块，虚拟机第一次加载该类，该初始化就会被执行；
// 不创建类实例，只会执行静态初始化块，不执行对象初始化块
public class Test {
// object initialization block
{
System.out.println(" object initialization block");
}
// static initialization block
static {
System.out.println(" static initialization block");
}
public static void main (String[] args) {
}
}
输出为：static initialization block
// 创建类实例情境下，先执行静态初始化块（因为类先被加载），再在构造实例时执行对象初始化块
public class Test {
// object initialization block
{
System.out.println(" object initialization block");
}
// static initialization block
static {
System.out.println(" static initialization block");
}
public static void main (String[] args) {
new Test();
}
}
输出为：
static initialization block
object initialization block
抽象类
-
包含一个或多个抽象方法的类本身必须被声明为抽象的；
-
抽象方法，不能有方法体：Abstract methods cannot have a body；
- 抽象类不能被实例化，但是可以定义一个抽象类的对象变量，只是它只能引用非抽象子类的对象。例如，
// 抽象父类Person
public abstract class Person {
}
// 子类Student
public class Student extends Person {
public static void main (String[] args) {
new Person(); // error：Person is abstract, cannot be instantiated
Person p = new Student(); // OK: 这里是正确的，p是一个抽象类Person的变量，Person引用了一个非抽象子类Student的对象
}
}
- 如上所述，抽象类变量可以引用非抽象子类的实例，并且可以通过该变量访问该引用子类的方法，如
// 抽象父类 Person 声明了抽象方法saying()
public abstract class Person {
public abstract void saying();
}
// 非抽象子类 Student 继承Person 并实现父类中声明的抽象方法saying()
public class Student extends Person {
public static void main (String[] args) {
Person p = new Student();
p.saying(); // 虽然Person中没有定义saying的具体实现，但是由于其引用的是子类实例，所以调用的子类的方法，
// 但是是否可以省略Person父类中的抽象方法saying呢?
// 答案是不行，因为编译器只允许调用类中声明的方法，Person中如何没有声明该方法，即便是引用的是子类实例，也不能调用子类中独有的方法
}
public void saying() {
System.out.println("Hello world");
}
}
- 在正常的类继承中，对上述情境进行试验：父类变量引用子类实例时，按继承链优先执行子类中的方法
public class Person {
public void saying(){
System.out.println("Person Hello world");
}
}
//-------------------- Student 子类中覆盖父类的saying方法 ----------------------------//
public class Student extends Person {
public static void main (String[] args) {
Person p = new Student();
p.saying();
}
public void saying() {
System.out.println(" Student Hello world");
}
}
输出结果为：Student Hello world
//-------------------- Student 子类中正常继承父类的saying方法 ----------------------------//
public class Student extends Person {
public static void main (String[] args) {
Person p = new Student();
p.saying();
}
}
输出结果为：Person Hello world
// --------------对比结论-------------- //
结论：父类变量引用子类实例时，按继承链优先执行子类中的方法
访问控制修饰符
