Java程序设计 面向对象进阶

final

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

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

使用final声明的变量即成为常量

在使用final声明变量的时候，要求全部的字母大写

子类测试

final class a{
}
class b extends a{
}
public class Hello {
    public static void main(String[] args) {
    }
}

Java程序设计 面向对象进阶_子类

方法重写测试

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();
    }
}

Java程序设计 面向对象进阶_后端_02

变量测试

public class Hello {
    public static void main(String[] args) {
        final String A="a";
        A="h";
    }
}

Java程序设计 面向对象进阶_java_03

抽象类

抽象类的作用有点类似“模版”，其目的是要设计者依据它的格式来修改并创建新的类。但是并不能直接由抽象类创建对象，只能通过抽象类派生出新的类，再由它来创建对象。但是在抽象类的使用中同样存在单继承的局限，即一个子类只能继承一个抽象类。

抽象类定义、使用规则：

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

抽象类和抽象方法都要使用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程序设计 面向对象进阶_java_04

抽象类与普通类的区别

如果使用普通类，那么子类可以根据自己的需要选择性的进行某些父类方法的覆写，所以普通类无法对子类覆写的方法进行限制。然而抽象类却可以强制性要求子类覆写父类方法，正因为如此，在实际的开发中，不建议让子类继承普通类，而只建议子类继承抽象类。

接口

接口是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();
    }
}

Java程序设计 面向对象进阶_抽象类_05

继承抽象类实现接口

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();
    }
}

Java程序设计 面向对象进阶_java_06

调用的方法是被子类所覆写过的方法，也就是说，如果对象发生了向上转型关系，所调用的方法肯定是被子类覆写过的方法

向小转型

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();
    }
}

Java程序设计 面向对象进阶_后端_07

想调用子类自己的方法，则只能用子类声明对象

在进行对象的向下转型之前，必须首先发生对象向上转型，否则将出现对象转换异常

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);
    }
}

Java程序设计 面向对象进阶_子类_08