abstract 关键字，局部变量 和 final 关键字

1. abstract 关键字

1.1 代码的实际问题

目前代码流程    
    继承 --> 调用 --> 出现业务问题 --> 重写 --> 解决问题。
期望的代码流程
    继承 --> 子类强制重写【不满足语法报错】 --> 用户完美使用
【期望】
    父类限制子类操作，必须强制重写必要方法。并非是在用户发现问题之后，在返工！！！

1.2 使用 abstract 关键字解决以上问题

abstract 关键字作用:

                 父类中使用 abstract 关键字修饰的成员方法，要求子类强制重写

  * 第一步:
 *         使用 abstract 关键字修饰目标方法
 *         【错误一】
 *                     Abstract methods do not specify a body
 *                     abstract 修饰的方法不能有方法体【语法要求】
 *         【语法总结】
 *                     abstract 修饰的方法没有方法体
 *        【Eclipse 快速修复】
 *                    Ctrl + 1 ==> 选择 Remove method body
 *                    Eclipse 快速修复建议选择 删除方法体

 *
 * 第二步:
 *         删除方法体之后，代码中依然存在问题
 *         【错误二】
 *                     The abstract method q in type LOLHero can only be defined by an abstract class
 *                         在 LOLHero 类内使用 abstract 修饰的方法 q 有且只能定义在一个 abstract 修饰的类内
 * 
 *                     The type LOLHero must be an abstract class to define abstract methods
 *                         LOLHero 类必须是一个 abstract 修饰的类才可以定义 abstract 修饰的方法。
 *         【语法总结】
 *                     abstract 修饰的方法必须定义在一个 abstract 修饰的类内
 *        【Eclipse 快速修复】
 *                    Ctrl + 1 ==> Make type 'LOLHero' abstract
 *                        Eclipse 快速修复建议选择 使用abstract 关键字修饰 LOLHero 类 
 *

 * 第三步:
 *         abstract 修饰 LOLHero 类
 *         【错误三】
 *                     The type Thresh must implement the inherited abstract method LOLHero.q()
 *                         锤石类必须【实现】通过继承得到的在 LOLHero 类内使用 abstract 关键字修饰的方法 q                
 * 
 *                     The type Varus must implement the inherited abstract method LOLHero.q()
 *                         维鲁斯类必须【实现】通过继承得到的在 LOLHero 类内使用 abstract 关键字修饰的方法 q        
 *             
 *             补充说明：
 *                         implement 实现 
 *                         因为 LOLHero 类内 abstract 修饰的方法没有方法体，严格来讲有且只有方法声明对应方法， 
 *                         没有实现。
 *         【语法总结】
 *                     子类如果没有 abstract 关键字修饰，必须【实现】父类中所有使用 abstract 修饰的没有方法体的方法
 *         【Eclipse 快速修复】
 *                     Ctrl + 1 ==> Add unimplemented methods
 *                         Eclipse 快速修复建议选择 添加尚未实现的所有父类 abstract 修饰方法

abstract class LOLHero {
	abstract public void q();

	public void w() {
		System.out.println("W技能");
	}

	public void e() {
		System.out.println("E技能");
	}

	public void r() {
		System.out.println("R技能");
	}
}

/**
 * 锤石类 继承 LOLHero
 * @author Anonymous
 *
 */
class Thresh extends LOLHero {

	@Override
	public void q() {
		System.out.println("死亡判决");
	}
	
}

/**
 * 维鲁斯类  继承 LOLHero
 * @author Anonymous
 *
 */
class Varus extends LOLHero {

	@Override
	public void q() {
		System.out.println("穿刺之箭");
	}
	
}

public class Demo2 {
	public static void main(String[] args) {
		Thresh thresh = new Thresh();
		Varus varus = new Varus();
		
		thresh.q();
		thresh.e();
		thresh.r();
		thresh.w();
		
		
		varus.e();
		varus.q();
		varus.w();
		varus.r();
	}
}

1.3 abstract 修饰的类无法实例化

 * 是否可以实例化/创建 abstract 修饰类对应的对象???
         * 
         * 假设:
         *         当前代码中实例化/创建了  BaseType 对象，
         *         请问当前 BaseType 对象调用 testAbstract 方法会有什么效果???
         * 分析: 
         *         testAbstract 方法使用 abstract 关键字修饰，对应方法没有方法体
         *         没有执行目标和执行内容。【无法执行，语法报错】
         * 
         * 假设不成立:
         *         abstract 关键字修饰的类，无法实例化/无法创建对象。
         * 
         * 为什么 abstract 修饰的类内语句全部都是正常的方法，为什么还是无法实例化
         *         1. abstract 关键字修饰的类，【有可能】存在 abstract 修饰的方法 
         *         2. abstract 修饰的方法要求没有方法体
         *         3. 如果实例化 abstract 修饰类，得到了对应的对象，就【有可能】存在没有方法体的
         *             采用 abstract 关键字修饰的方法。无法执行语法报错、
         *         开发中【有可能】出现错误 ==> 一定会出现错误 ==> 【语法错误】

1.4 abstract 关键字使用总结

1. abstract 修饰的方法没有方法体。
    abstract 关键字的重点是在于修饰方法
2. abstract 修饰的方法，要求继承当前 abstract 所在类对应的子类必须强制实现对应的 abstract 方法。
    子类非 abstract 修饰，继承 abstract 对应的父类，必须实现所有的 abstract 方法
3. abstract 修饰的方法，有且只能够定义在 abstract 修饰的类内 或者 interface 接口内
4. abstract 修饰的类无法实例化。
    因为 abstract 关键字修饰的类中，有可能存在只有方法声明的 abstract 修饰方法，这一类方法无法实例化对象调用
    执行。

2. 局部变量

2.1 什么是局部变量

定义在方法中的变量 ==> 局部变量

2.2 局部变量特征

特征:
    1. 局部变量先定义后使用
    2. 局部变量如果在没有被赋值的情况下，有且只能参与赋值操作，其他任何操作无法执行。
    3. 局部变量在定义对应的大括号范围有效，一旦超出范围无效
        大括号范围 方法体大括号，分支结构，循环结构
    4. 局部变量在有效范围以内唯一，不可以重复定义。
    5. 局部变量在内存的【栈区】
    6. 局部变量主要用于在代码运行过程中，针对于数据的临时存储和使用
        int num = 10;
        num += 10;
        num = 20;
    7. 【生存周期】和【作用范围】都在对应大括号范围以内

2.3 成员变量特征

特征:
    1. 成员变量定义在 class 大括号以内
    2. 成员变量主要作用描述当前类所具备的属性。
    3. 成员变量是在实例化对象之后，存储在内存的【堆区】
    4. 成员变量
        【生存周期】
            从实例化对象开始，到当前对象被销毁结束。
            JVM 的 GC 垃圾回收机制
        【作用范围】
            作用范围取决于当前对象在哪里

3. final 关键字

3.1 修饰成员变量

特征总结

1. final 修饰的成员变量一旦被赋值，后期无法修改，可以认为是带有名称的常量

2. final 修饰的成员变量定义时必须初始化，赋值方式有两种

   2.1 定义时直接赋值对应的数据内容

   2.2 【高阶用法】使用构造方法给予 final 修饰成员变量初始化赋值操作

class TypeA {
	// 定义 public 修饰的成员变量 num 初始化为 10
	public int num = 10;
	
	/*
	 * public final 修饰的成员变量
	 * 【报错】	
	 * The blank final field msg may not have been initialized
	 * 		final 修饰的成员变量 msg 可能尚未初始化
	 * 【注意】
	 * 		final 修饰的成员变量定义时必须初始化！！！
	 * 		初始化赋值手段有两种
	 * 			1. 定义时直接赋值对应的数据内容
	 * 				public final String msg = "你好"; 
	 * 			2. 【高阶用法】使用构造方法给予 final 修饰成员变量初始化赋值操作
	 */	
	public final String msg; 
	
	public TypeA(String msg) {
		this.msg = msg;
	}
}

public class Demo1 {
	public static void main(String[] args) {
		TypeA typeA = new TypeA("测试");
		
		System.out.println(typeA.num);
		System.out.println(typeA.msg);
		
		// 没有 final 修饰的成员变量，重新赋值 OK!
		typeA.num = 20;
		
		/*
		 * 【报错】
		 * The final field TypeA.msg cannot be assigned
		 * 		TypeA 类使用 final 修饰的成员变量 msg 不能被赋值
		 * 【注意】
		 * 		final 修饰的成员变量一旦被赋值，后期无法修改，可以认为是
		 * 		带有名称的常量
		 */
		// typeA.msg = "郑州加油！";
	}
}

3.2 修饰成员方法

特征总结:

1. final 修饰的方法不能被重写

2. final 修饰的方法常见于核心业务逻辑，例如 支付

class TypeB {
	final public void test() {
		System.out.println("正常方法");
	}
}

class TypeC extends TypeB {
	/*
	 * 【错误】
	 * 		Cannot override the final method from TypeB
	 * 		子类不能重写 TypeB 类内 final 修饰的成员方法 
	 * 【注意】
	 * 		final 修饰的成员方法为最终方法，无法被重写！！！
	 * 【作用】
	 * 		限制项目中的核心业务逻辑，重要业务逻辑
	 * 		例如 支付操作
	 */
	@Override
	public void test() {
		System.out.println("重写");
	}
}

public class Demo2 {
	public static void main(String[] args) {
		TypeC typeC = new TypeC();
		typeC.test();
	}
}

3.3 修饰类

特征总结:

1. final 修饰的类不能被继承，没有子类

2. Java 中的 String 类型就是 final 修饰的类型。

3.4 修饰局部变量

特征总结:

1. final 修饰的局部变量有且只能被赋值一次，赋值之后无法修改

2. 引用数据类型使用 final 修饰，引用指向不可变，但是指向空间数据内容可变