06_JavaSE之OOP--面向对象（final、抽象类、接口）

对象（六）

首先，在复习抽象类和接口之前，先来看一个关键字：final.　　

1.概述：
　　final是最终的，那么他修饰类、变量、方法就会不能被修改。

2.final修饰的特点： 

a.修饰类，类不能被继承

b.修饰变量，变量就成了常量，只能被赋值一次

c.修饰方法，方法不能被重写

修饰类

 1 final class Father {    //修饰类
 2     public void print() {
 3         System.out.println("上九天揽月");
 4     }
 5 }
 6 //报错，不能被继承
 7 class Son extends Father {
 8     public void print() {
 9         System.out.println(“下五洋捉鳖”);
10     }
11 }

View Code

修饰变量

1 class Son {
2     final int NUM = 10;                        //常量命名规范,如果是一个单词,所有字母大写,如果是多个单词,每个单词都大写,中间用下划线隔开
3     public static final double PI = 3.14;    //final修饰变量叫做常量,一般会与public static共用
4     public void print() {
5         NUM = 20;    //报错，不能被改变
6         System.out.println(NUM);
7     }
8 }

View Code

修饰方法

 1 class Father {
 2     public final void print() {
 3         System.out.println("来啊");
 4     }
 5 }
 6 
 7 class Son extends Father {
 8     public void print() {    //报错，不能被重写
 9         System.out.println(“访问你”);
10     }
11 }

View Code

3.final修饰基本类型与引用类型：

基本类型：  值不能被改变。

引用类型：  地址值不能改变，对象中的属性可以改变。

 

一、抽象类（abstract class）

从某种程度上讲，父类或者祖先类更加的通用，人们将他派生为其他的子类或者基类，而不是操作具体某个实例类。

为什么要抽象呢？抽象表面就是看不懂的，而在这里就是把一些共性抽取出来加以更加方便的使用，提高代码的可维护性，复用性。

如：每个人都有名字、年龄这样的属性，我们将这些放父类当中加以抽象出来，而通过set/get方法去操作他们，程序也更加清晰。

1.抽象类特点

a.抽象类和抽象方法都必须用abstract关键字进行修饰

　　abstract class 类名 { }　　　　//抽象类

　　public abstract void play();　　//抽象方法

b.抽象类不一定有抽象方法，有抽象方法的一定是抽象类

c.抽象类一定不能被实例化，那么，抽象类如何实例化呢？

　　按照多态的方式，有具体的子类去实现实例化。其实，这也是多态的一种，抽象类多态。

d.抽象类的子类，要么也是抽象类，要么重写抽象类中所有的抽象方法。

 1 public class TestAbstract {
 2     public static void main(String[] args){
 3         // Person person = new Person();   报错，抽象类不能实例化
 4         Person p = new Girl();
 5         p.buy();
 6     }
 7 }
 8 
 9 abstract class Person {          //抽象类
10     public abstract void buy(); //抽象方法
11 }
12 
13 class Girl extends Person{
14     @Override
15     public void buy() {
16         System.out.println("买买买");
17     }
18 }

 

2.抽象类的成员特点

a.成员变量：既可以是变量，也可以是常量。abstract是否可以修饰成员变量？不能修饰成员变量。

b.构造方法：有。
用于子类访问父类数据的初始化。

c.抽象类的成员方法特性：
　　抽象方法：强制要求子类做的事情。
　　费抽象方法：子类继承的事情，提高代码复用性。

3.抽象类的一些问题

A.一个抽象类如果没有抽象方法，可不可以定义为抽象类？如果可以，有什么意义？
可以。

这么做的目的只哟一个，就是不让其他类创建本类对象，交个子类完成。

B.abstract不能和哪些关键字共存？

static

被abstract修饰的方法没有方法体

被static修饰的可以用类名.调用，但是类名.调用抽象方法是没有意义的。

final

被abstract修饰的方法强制子类重写

被final修饰的不能让子类重写，所以他两矛盾。

private

被abstract修饰的希望子类看到并强制重写。

被private修饰的不能让子类访问。

 

---

二、接口（interface）

 1.接口的概述

① 接口从狭义上讲就是指java的interface。

② 从广义上就是指对外提供规格的都是接口

2.接口的特点

　　a.接口都用关键字interface表示

　　　　interface 接口名 { }

　　b.类实现接口用implements表示

　　　　class 类名 implements 接口名 { }

　　c.接口不能被实例化

　　　　如果要实例化，那么必须是按照多态的形式来实例化，这一点和抽象类很像。

　　d.接口的子类：可以是抽象类，但是意义不大。也可以是具体类，要重写接口中所有的抽象方法。（推荐）

 code：

 1 public class Demo_Interface {
 2     public static void main(String[] args){
 3         //Dog er = new Dog();   报错，接口不能实例化
 4         Dog er = new ErHa();　　//父类引用指向子类对象
 5         er.watchChild();
 6     }
 7 }
 8 
 9 interface Dog {
10     public void watchChild();
11 }
12 
13 class ErHa implements Dog {
14 
15     @Override
16     public void watchChild() {
17         System.out.println("二哈看小孩");
18     }
19 }

 

3.接口中成员的特点

成员变量：只能是常量，并且是静态的，公共的。

　　　　　 默认修饰符：public static final

　　　　　 建议：自己手动给出。

构造方法：接口中没有构造方法。

成员方法：只能是抽象方法。

　　　　　 默认修饰符：public abstract

　

4.类与类，类与接口，接口与接口的关系

a.类与类：单继承关系，不可以多继承。但是可以多层继承。　　

b.类与接口：实现关系，可以单实现，也可以多实现。并且还可以在一个继承一个类的同时实现多个接口。

c.接口与接口：继承关系，可以单继承，也可以多继承。

 

5.抽象类与接口的区别

 1）成员区别：

 

	抽象类		接口
成员变量	可以是变量，也可以是常量		只可以是常量
构造方法	有		无
成员方法	可以抽象，也可以不抽象		只可以抽象

 

 

2）关系区别：

类与类	继承，单继承
类与接口	实现，单实现，多实现
接口与接口	继承，单继承，多继承

 

 

3）设计理念的区别：

 

抽象类	被继承体现的是：“is - a”的关系。抽象类中定义的是该继承体系的共性功能。
接口	被实现体现的是：“like - a”的关系。接口中体现的是该继承体系的扩展功能

 

 

如有错误之处，欢迎指正。

邮箱：[e-mail]