欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

06_JavaSE之OOP--面向对象(final、抽象类、接口)

程序员文章站 2022-04-28 09:23:05
对象(六) 首先,在复习抽象类和接口之前,先来看一个关键字:final. 1.概述: final是最终的,那么他修饰类、变量、方法就会不能被修改。 2.final修饰的特点: a.修饰类,类不能被继承 b.修饰变量,变量就成了常量,只能被赋值一次 c.修饰方法,方法不能被重写 修饰类 1 final ......

对象(六)

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

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

2.final修饰的特点: 

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

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

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

修饰类

06_JavaSE之OOP--面向对象(final、抽象类、接口)
 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

修饰变量

06_JavaSE之OOP--面向对象(final、抽象类、接口)
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

修饰方法

06_JavaSE之OOP--面向对象(final、抽象类、接口)
 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 }

06_JavaSE之OOP--面向对象(final、抽象类、接口)

 

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”的关系。接口中体现的是该继承体系的扩展功能
 

 

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

邮箱:it_chang@126.com