面向对象高级——final关键字的使用以及抽象类的基本概念

本文主要是介绍面向对象高级——final关键字的使用以及抽象类的基本概念，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

final关键字

final关键字在java中表示的是最终的意思。也可以成为完结器。

可以使用final关键字声明类、属性、方法：

使用final声明的类不能有子类；

使用final声明的方法不能被子类所覆写；

使用final声明的变量即成为常量，常量不可以被修改；

final class A{	// 使用final定义类，不能有子类
};
class B extends A{	// 错误，不能被继承
};

太监不能有后代，可以把final声明的类称为太监类。

class A{public final void print(){	// 使用final声明的方法不能被覆写System.out.println("HELLO") ;}
};
class B extends A{public void print(){	// 错误，不能被覆写System.out.println("MLDN") ;}
};

使用final声明的变量就是常量，常量的内容是不可以修改的，且常量必须在声明的时候明确指定其内容；

class A{private final String INFO = "INFO" ;	// 声明常量public final void print(){	// 使用final声明的方法不能被覆写INFO = "HELLO" ; // 错误：常量的内容是不可以被修改的}
};

从使用中可以发现，此时使用final声明的变量的字母全部采用大写的形式，所以这也是一个命名要求，即：常量必须全部大写。

全局常量

使用static final 关键字联合声明的变量称为全局常量。

public static final String INFO = "LX";

static声明的内容是所有对象共同拥有的。

总结：在一般的开发中，使用final定义的常量是最多的。使用static final可以声明全局常量。

抽象类

目标：

掌握抽象类的定义格式

掌握抽象类的使用规则

具体内容：

抽象类的概念：包含一个抽象方法的类就称为抽象类。

抽象方法：只声明而未实现的方法称为抽象方法，抽象方法必须使用abstract关键字声明

抽象类的定义及使用规则：

包含一个抽象方法的类必须是抽象类。

抽象类和抽象方法都要使用abstract关键字声明。

抽象方法只需要声明不需要实现；

抽象类必须被继承，子类（如果不是抽象类）必须覆写抽象类中的全部抽象方法。

抽象类的定义格式如下：

abstract class A{	// 是定义了一个抽象类public static final String FLAG = "CHINA" ;	// 全局常量private String name = "刘勋" ;	// 定义一个普通的属性public void setName(String name){this.name = name ;}public String getName(){return this.name ;}public abstract void print() ;		// 定义抽象方法
};

从定义上看，抽象类就是比普通类多一个抽象方法而已。

abstract class A{	// 是定义了一个抽象类public static final String FLAG = "CHINA" ;	// 全局常量private String name = "刘勋" ;	// 定义一个普通的属性public void setName(String name){this.name = name ;}public String getName(){return this.name ;}public abstract void print() ;		// 定义抽象方法
};
class B extends A{	// 继承抽象类，因为B是普通类，所以必须覆写全部抽象方法public void print(){System.out.println("FLAG = " + FLAG) ;System.out.println("姓名 = " + super.getName()) ;}
};
public class AbstractDemo02{public static void main(String args[]){B b = new B() ;b.print() ;}
};

类名称采用斜体表示是一个抽象类。

问题一：不能使用final关键字声明

final定义的类是不能有子类的

抽象类是必须有子类的。

如下声明是绝对不允许的

final abstract class A{
};

举例如下：

abstract class A{	// 是定义了一个抽象类public A(){System.out.println("A、抽象类中的构造方法。") ;}
};
class B extends A{	// 继承抽象类，因为B是普通类，所以必须覆写全部抽象方法public B(){super() ;System.out.println("B、子类中的构造方法。") ;}
};
public class AbstractDemo03{public static void main(String args[]){B b = new B() ;}
};

当然，也可以通过super明确的指明要调用的构造方法。

abstract class Person{private String name ;		// 定义name属性private int age ;			// 定义age属性public Person(String name,int age){this.name = name ;this.age = age ;}public void setName(String name){this.name = name ;}public void setAge(int age){this.age = age ;}public String getName(){return this.name ;}public int getAge(){return this.age ;}public abstract String getInfo() ;	// 抽象方法
};
class Student extends Person{private String school ;public Student(String name,int age,String school){super(name,age) ;	// 指定要调用抽象类中有两个参数的构造方法this.school = school ;}public void setSchool(String school){this.school = school ;}public String getSchool(){return this.school ;}public String getInfo(){return	"姓名：" + super.getName()  + "；年龄：" + super.getAge() + "；学校：" + this.getSchool() ;}
};
public class AbstractDemo04{public static void main(String args[]){Student stu = new Student("张三",30,"清华大学") ;System.out.println(stu.getInfo()) ;}
};