Java程序设计 面向对象进阶
final
使用final声明的类不能有子类
使用final声明的方法不能被子类所重写
使用final声明的变量即成为常量
在使用final声明变量的时候，要求全部的字母大写
子类测试
final class a{
}
class b extends a{
}
public class Hello {
public static void main(String[] args) {
}
}
方法重写测试
class a{
public final void p(){
}
}
class b extends a{
public void p(){
System.out.println("1");
}
}
public class Hello {
public static void main(String[] args) {
b s = new b();
}
}
变量测试
public class Hello {
public static void main(String[] args) {
final String A="a";
A="h";
}
}
抽象类
抽象类的作用有点类似“模版”，其目的是要设计者依据它的格式来修改并创建新的类。但是并不能直接由抽象类创建对象，只能通过抽象类派生出新的类，再由它来创建对象。但是在抽象类的使用中同样存在单继承的局限，即一个子类只能继承一个抽象类。
抽象类定义、使用规则：
包含一个抽象方法的类必须是抽象类
抽象类和抽象方法都要使用abstract关键字声明
抽象方法只需声明而不需要实现
抽象类必须被子类继承，子类（如果不是抽象类）必须覆写抽象类中的全部抽象方法
格式：
abstract class 抽象类名称{
属性;
访问权限 返回值类型 方法名称(参数){
[return 返回值];
}
访问权限 abstract 返回值类型 方法名称(参数);
}
演示：
//定义抽象类
abstract class a{
private String test="A";
public String getTest() {
return test;
}
public void setTest(String test) {
this.test = test;
}
public abstract void print();
}
//继承抽象类
class b extends a{
public void print(){
System.out.println(super.getTest());
}
}
public class Hello {
public static void main(String[] args) {
new b().print();
}
}
抽象类与普通类的区别
如果使用普通类，那么子类可以根据自己的需要选择性的进行某些父类方法的覆写，所以普通类无法对子类覆写的方法进行限制。然而抽象类却可以强制性要求子类覆写父类方法，正因为如此，在实际的开发中，不建议让子类继承普通类，而只建议子类继承抽象类。
接口
接口是Java中最重要的概念之一，接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成。
格式：
interface 接口名称{
全局常量;
抽象方法;
}
实现接口
class 子类 implements 接口A,接口B,..{
}
演示：
//定义接口
interface a{
String a="测试";
void print();
}
//实现接口
class b implements a{
public void print(){
System.out.println(a);
}
}
public class Hello {
public static void main(String[] args) {
new b().print();
}
}
继承抽象类实现接口
class 子类 extends 抽象类 implements 接口A,接口B,..{
}
抽象类实现接口
abstract class B implements 接口{
}
接口的继承
interface 子接口 extends 父接口A,父接口B,..{
}
多态
在Java中面向对象主要体现：
方法的重载与重写
对象的多态性
对象的多态性为两种类型：向上转型、向下转型
对象向上转型：父类 父类对象 = 子类实例;
对象向下转型：子类 子类对象 = （子类）父类实例;
向上转型
class a{
public void test(){
System.out.println("a-test");
}
}
class b extends a{
public void test(){
System.out.println("b-test");
}
}
public class Hello {
public static void main(String[] args) {
b t = new b();
a t2=t;
t2.test();
}
}
调用的方法是被子类所覆写过的方法，也就是说，如果对象发生了向上转型关系，所调用的方法肯定是被子类覆写过的方法
向小转型
class a{
public void test(){
System.out.println("a-test");
}
}
class b extends a{
public void test(){
System.out.println("b-test");
}
public void test1(){
System.out.println("345");
}
}
public class Hello {
public static void main(String[] args) {
// 向上转型
a t=new b();
// 向下转型
b t2=(b)t;
t2.test();
t2.test1();
}
}
想调用子类自己的方法，则只能用子类声明对象
在进行对象的向下转型之前，必须首先发生对象向上转型，否则将出现对象转换异常
instanceof
使用instanceof关键字判断一个对象到底是哪个类的实例
class a{
}
class b extends a{
}
public class Hello {
public static void main(String[] args) {
a t1=new b();
a t2=new a();
System.out.println(t1 instanceof a);
System.out.println(t1 instanceof b);
System.out.println(t2 instanceof a);
System.out.println(t2 instanceof b);
}
}
