由浅到深认识Java语言（15）：final关键字&抽象类

该文章Github地址：https://github.com/AntonyCheng/java-notes【有条件的情况下推荐直接访问GitHub以获取最新的代码更新】

在此介绍一下作者开源的SpringBoot项目初始化模板（Github仓库地址：https://github.com/AntonyCheng/spring-boot-init-template【有条件的情况下推荐直接访问GitHub以获取最新的代码更新】& CSDN文章地址：https://blog.csdn.net/AntonyCheng/article/details/136555245），该模板集成了最常见的开发组件，同时基于修改配置文件实现组件的装载，除了这些，模板中还有非常丰富的整合示例，同时单体架构也非常适合SpringBoot框架入门，如果觉得有意义或者有帮助，欢迎Star & Issues & PR！

上一章：由浅到深认识Java语言（14）：多态

24.final关键字

final 表示最终的，无法修改的；

final 可以修饰类，属性和方法；

final 修饰类（太监类）

该类无法被继承；

示例如下：

final class A{
	public void method() {
		System.out.println("A.method");
	}
}
class B extends A{  //这里会报错！！！
	public void method() {
		System.out.println("B.method");
	}
}

final修饰属性（常量）

final修饰变量就是常量；

成员变量示例如下：

package top.sharehome.BagOne;

public class Demo {
	public static void main(String[] args) {
		A a = new A();
		a.c = 9;  //这里会报错！！！因为c没办法修改！！
	}
}
class A {
	final int c = 10;
	public void method() {
		System.out.println(c);
	}
}

局部变量示例如下：

package top.sharehome.BagOne;

public class Demo {
	public static void main(String[] args) {
		final int MY_INT;
		System.out.println(MY_INT);  //这里会报错，因为 MY_INT 没有值
	}
}

静态常量实例如下：

final static int MY_INT = 10;

静态常量也称为全局常量；

常量总结：

所有的常量都必须显式地赋值（等号，代码块），且只能赋值一次，才能正常使用；

final修饰方法

final 修饰方法后不能被重写；

禁止重写实例如下：

class A{
	public final void method() {
		System.out.println("A.method");
	}
}
class B extends A{
	public void method() { //这里会报错，因为final方法不能被重写 
		System.out.println("B.method");
	}
}

25.抽象类（abstract关键字）

定义

抽象类没有具体的代码实现，只是规定的方法的基本属性，然后由子类去实现具体的代码，抽象类主要是为了定义规则而存在；

举例如下：

Person 类：

package top.sharehome.BagOne;

public class Person {
	public void sleep() {				//没有实际作用，因为子类要重写
		System.out.println("人睡觉");  
	}									
	public void eat() {					//没有实际作用，因为子类要重写
		System.out.println("人吃饭");
	}
	public void walking() {				//没有实际作用，因为子类要重写
		System.out.println("人走路");
	}
}

Student 类：

package top.sharehome.BagOne;

public class Student extends Person{
	public void sleep() {
		System.out.println("学生睡觉");
	}
	public void eat() {
		System.out.println("学生吃饭");
	}
	public void walking() {
		System.out.println("学生走路");
	}
}

Farmer 类：

package top.sharehome.BagOne;

public class Farmer extends Person{
	public void sleep() {
		System.out.println("农场主睡觉");
	}
	public void eat() {
		System.out.println("农场主吃饭");
	}
	public void walking() {
		System.out.println("农场主走路");
	}
}

Demo 类：

package top.sharehome.BagOne;

public class Demo {
	public static void main(String[] args) {
		Student s = new Student();
		Farmer f = new Farmer();
		s.sleep();
		s.eat();
		s.walking();
		f.sleep();
		f.eat();
		f.walking();
	}
}

打印效果如下：

问题：

我们发现一个父类定义的功能（方法），子类都要去重写，也就是说这个父类的方法的具体内容不再重要了，但是这个方法又不能没有，比如一个人不能没有吃饭的功能，具体怎么吃是子类的功能。于是，将父类中这样的方法（必须有方法的定义，可以没有方法的具体实现），定义成抽象方法，既制定了规则，又提高了效率；

抽象方法

只定义了方法，但是没有具体的实现；

基本格式:

权限修饰符 abstract 返回值类型 方法名(参数列表);

比较举例：

//普通方法：
public void method(){}
//抽象方法：
public abstract void method();

抽象类

基本格式：

abstract class 类名{}

注意事项：

• 有抽象方法的类，必须是抽象类，即必须用 abstract 修饰；

• 抽象类可以有普通方法、抽象方法、普通的属性、构造器，代码块和内部类，也可以没有抽象方法；

  • 不能被创建对象，为什么有构造器？

    因为子类的调用需要父类的构造器被调用，所以不能直接被创建，但是构造器会被调用；

• 抽象类不能被创建对象，如果要想创建对象，就必须创建一个该抽象类的子类，然后创建子类的对象并且重写抽象类中继承而来的抽象方法，然后运用多态调用抽象类；

实例：抽象类演示

Person 类：

package top.sharehome.BagOne;

public abstract class Person {
	public abstract void sleep();
	public abstract void eat();
	public abstract void walking();
}

Student 类：

package top.sharehome.BagOne;

public class Student extends Person{
	public void sleep() {
		System.out.println("学生睡觉");
	}
	public void eat() {
		System.out.println("学生吃饭");
	}
	public void walking() {
		System.out.println("学生走路");
	}
}

Farmer 类：

package top.sharehome.BagOne;

public class Farmer extends Person{
	public void sleep() {
		System.out.println("农场主睡觉");
	}
	public void eat() {
		System.out.println("农场主吃饭");
	}
	public void walking() {
		System.out.println("农场主走路");
	}
}

Demo 类：

package top.sharehome.BagOne;

public class Demo {
	public static void main(String[] args) {
		Student s = new Student();
		Farmer f = new Farmer();
		s.sleep();
		s.eat();
		s.walking();
		f.sleep();
		f.eat();
		f.walking();
	}
}

打印效果如下：

实例：创建抽象类对象

Person 类：

package top.sharehome.BagOne;

public abstract class Person {		//类的抽象化
	public abstract void sleep();  
	public abstract void eat();
	public abstract void walking();
}

Student 类：

package top.sharehome.BagOne;

public class Student extends Person{
	public void sleep() {				//抽象方法重写
		System.out.println("学生睡觉");
	}
	public void eat() {
		System.out.println("学生吃饭");
	}
	public void walking() {
		System.out.println("学生走路");
	}
}

Demo 类：

package top.sharehome.BagOne;

public class Demo {
	public static void main(String[] args) {
		Person p =new Student();		//多态的调用
		p.sleep();
		p.eat();
		p.walking();
	}
}

打印效果如下：

下一章：由浅到深认识Java语言（16）：接口