JAVA基础再回首(七)——final关键字、抽象类abstract、接口interface、权限修饰符、导包

原创 2016年08月03日 21:04:14

JAVA基础再回首(七)——final关键字、抽象类abstract、接口interface、权限修饰符、导包

没有到不了的明天。
嬉皮笑脸面对人生的难。
相信自己,不然你什么都做不了。

final关键字


  • final关键字是最终的意思,可以修饰类,成员变量,成员方法。
    • 修饰类,类不能被继承
    • 修饰变量,变量就变成了常量,只能被赋值一次
    • 修饰方法,方法不能被重写

我们可以写一个Demo来验证一下final关键字
class Fu {
    public int num = 10;
    public final int num2 = 20;

    /*
    public final void show() {
    }
    */
}
class Zi extends Fu {
    // Zi中的show()无法覆盖Fu中的show()
    public void show() {
        num = 100;
        System.out.println(num);
        //无法为最终变量num2分配值
        //num2 = 200; //打开注释会报错
        System.out.println(num2);
    }
}
public class FinalDemo{
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }
}

输出结果:
100
20

那么final在继承中如何体现呢?

由于继承中方法有一个现象:方法重写。所以,父类的功能就会被子类覆盖掉。有时候为了不让子类去覆盖掉父类的功能,只能让他用,所以,针对这种情况,java就提供了一个关键字:final。

class Fu {
    public final void show() {
        System.out.println("这里是绝密资源,任何人都不能修改");
    }
}
class Zi extends Fu {
    // Zi中的show()无法覆盖Fu中的show()
//  public void show() {
//      System.out.println("这是一堆垃圾");
//  }
}
public class FinalDemo{
    public static void main(String[] args) {

        Zi z = new Zi();
        z.show();
    }
}

输出结果:
肯定是父类中的输出结果了。

抽象类(abstract)

概述:
动物不应该定义为具体的东西,而且动物中的吃,睡等也不应该是具体的。
我们把一个不是具体的功能称为抽象的功能,而一个类中如果有抽象的功能,该类必须是抽象类。

  • 抽象类特点
    • 抽象类和抽象方法必须用abstract关键字修饰
      • 格式
      • abstract class 类名 {}
      • public abstract void eat();
    • 抽象类不一定有抽象方法,有抽象方法的类一定是抽象类
    • 抽象类不能实例化
      • 因为它不是具体的。
      • 那么,抽象类如何实例化呢?
      • 按照多态的方式,由具体的子类实例化。其实这也是多态的一种,抽象类多态。
    • 抽象类的子类
      • 如果不想重写抽象方法,该子类是一个抽象类。
      • 重写所有的抽象方法,这个时候子类是一个具体的类。
abstract class Animal {
    //抽象方法
    //public abstract void eat(){} //空方法体,这个会报错。抽象方法不能有主体
    public abstract void eat();

    public Animal(){}
}

//子类是抽象类
abstract class Dog extends Animal {}

//子类是具体类,重写抽象方法
class Cat extends Animal {
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

输出结果:猫吃鱼

  • 抽象类的成员特点:
    • 成员变量:既可以是变量,也可以是常量。
    • 构造方法:构造方法不能被实例化。所以构造方法的特点是:用于子类访问父类数据的初始化。
  • 抽象类的成员方法特性:
    • 可以有抽象方法,强制要求子类做的事情。
    • 也可以有非抽象方法,子类继承的事情,提高代码复用性。
abstract class Animal {
    public int num = 10;
    public final int num2 = 20;

    public Animal() {}

    public Animal(String name,int age){}

    public abstract void show();

    public void method() {
        System.out.println("method");
    }
}


class Dog extends Animal {
    public void show() {
        System.out.println("show Dog");
    }
}
public class AbstractDemo {

    public static void main(String[] args) {
                //创建对象
                Animal a = new Dog();
                a.num = 100;
                System.out.println(a.num);
                //a.num2 = 200;
                System.out.println(a.num2);
                System.out.println("--------------");
                a.show();
                a.method();
    }
}

输出结果:
这里写图片描述

我们学习了抽象方法,但是让我有两个疑惑的问题,不知道你们是不是也同样疑惑,我给大家解答一下。

  1. 一个类如果没有抽象方法,可不可以定义为抽象类?如果可以,有什么意义?

    答案肯定是可以的,意义就是为了不让创建对象。

  2. abstract不能和哪些关键字共存?

    private冲突、final冲突、static无意义
    下面我们实例一个Demo

public class AbstractDemo {

    public static void main(String[] args) {
        Father.methods();
    }
}
abstract class Father{
    //public abstract void show();
    //非法的修饰符组合: abstract和private
    //private abstract void show();

    //非法的修饰符组合  abstract和final
    //final abstract void show();   

    //非法的修饰符组合abstract和static 
    //static abstract void show();

    public static void methods() {
        System.out.println("method");
    }
}

class Son extends Father {
    public void show() {}
}

接口(interface)

  • 接口用关键字interface表示
    • 格式:interface 接口名 {}
  • 类实现接口用implements表示
    • 格式:class 类名 implements 接口名 {}
  • 接口不能实例化
    • 那么,接口如何实例化呢?
    • 按照多态的方式,由具体的子类实例化。其实这也是多态的一种,接口多态(下一节讲)。
  • 接口的子类
    • 可以是抽象类。但是意义不大。
    • 可以是具体类。要重写接口中的所有抽象方法。(推荐方案)
//定义动物培训接口
interface AnimalTrain {
    public abstract void jump();
}
//抽象类实现接口
abstract class Dog implements AnimalTrain {
}
//具体类实现接口
class Cat implements AnimalTrain {
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}
public class InterfaceDemo {

    public static void main(String[] args) {
                //AnimalTrain是抽象的; 无法实例化
                //AnimalTrain at = new AnimalTrain();
                //at.jump();

                AnimalTrain at = new Cat();
                at.jump();
    }
}

输出结果:猫可以跳高了

  • 接口成员特点
    • 成员变量;只能是常量,并且是静态的。
    • 默认修饰符:public static final
    • 建议:自己手动给出。
  • 构造方法:接口没有构造方法。因为接口主要是扩展功能的,而没有具体存在
  • 成员方法:只能是抽象方法。
    • 默认修饰符:public abstract
    • 建议:自己手动给出。
interface Inter {
    public int num = 10;
    public final int num2 = 20;
    public static final int num3 = 30;

    //错误: 需要<标识符>,接口没有构造方法
    //public Inter() {}

    //接口方法不能带有主体
    //public void show() {}

    //abstract void show(); //默认public
    public void show(); //默认abstract
}

class InterImpl extends Object implements Inter {
    public InterImpl() {
        super();
    }

    @Override
    public void show() {

    }
}
public class InterfaceDemo {

    public static void main(String[] args) {
                //创建对象
                Inter i = new InterImpl();
                System.out.println(i.num);
                System.out.println(i.num2);
                //i.num = 100;
                //i.num2 = 200;
                //System.out.println(i.num); //无法为最终变量num分配值
                //System.out.println(i.num2);//无法为最终变量num2分配值
                System.out.println(Inter.num);
                System.out.println(Inter.num2);

    }
}

输出结果:
10
20
10
20

类与类,类与接口以及接口与接口的关系

觉得他们的关系好复杂,快看晕了,没关系,我们逐个学习

  • 类与类:
    • 继承关系,只能单继承,可以多层继承。
  • 类与接口:
    • 实现关系,可以单实现,也可以多实现。
    • 并且还可以在继承一个类的同时实现多个接口。
  • 接口与接口:
    • 继承关系,可以单继承,也可以多继承
interface Father{
    public abstract void show();
}

interface Mother {
    public abstract void show2();
}

interface Sister extends Father,Mother {

}
class Son extends Object implements Father,Mother {
    public void show() {
        System.out.println("show son");
    }

    public void show2() {
        System.out.println("show2 son");
    }
}
public class InterfaceDemo {

    public static void main(String[] args) {
                //创建对象
                Father f = new Son();
                f.show();
                //f.show2(); //报错

                Mother m = new Son();
                //m.show(); //报错
                m.show2();

    }
}

输出结果:
show2 son
show son

上面我们学习了抽象类,又学习了接口。那么他们之间有什么区别呢?我们继续开车…

抽象类和接口的区别

  • 成员区别

    • 抽象类:
      • 成员变量:可以变量,也可以常量
      • 构造方法:有
      • 成员方法:可以抽象,也可以非抽象
    • 接口:
      • 成员变量:只可以常量
      • 成员方法:只可以抽象
  • 关系区别

    • 类与类
      • 继承,单继承
    • 类与接口
      • 实现,单实现,多实现
    • 接口与接口
      • 继承,单继承,多继承
  • 设计理念区别
    • 抽象类
      • 被继承体现的是:”is a”的关系。
      • 抽象类中定义的是该继承体系的共性功能。
    • 接口
      • 被实现体现的是:”like a”的关系。
      • 接口中定义的是该继承体系的扩展功能。

权限修饰符

  • 修饰符:
    • 权限修饰符:private,默认的,protected,public
    • 状态修饰符:static,final
    • 抽象修饰符:abstract
  • 类:
    • 权限修饰符:默认修饰符,public
    • 状态修饰符:final
    • 抽象修饰符:abstract
      • 用的最多的就是:public
  • 成员变量:
    • 权限修饰符:private,默认的,protected,public
    • 状态修饰符:static,final
      • 用的最多的就是:private
  • 构造方法:
    • 权限修饰符:private,默认的,protected,public
      • 用的最多的就是:public
  • 成员方法:
    • 权限修饰符:private,默认的,protected,public
    • 状态修饰符:static,final
    • 抽象修饰符:abstract
      • 用的最多的就是:public
  • 除此以外的组合规则:
    • 成员变量:
      • public static final
    • 成员方法:
      • public static
      • public abstract
      • public final

最后我们在学一个小知识点——>导包

导包

  • 导包概述
    • 不同包下的类之间的访问,我们发现,每次使用不同包下的类的时候,都需要加包的全路径。比较麻烦。这个时候,java就提供了导包的功能。
  • 导包格式
    • import 包名;
  • 注意:
    • 我们用那个报就导那个包。

那么,package,import,class有没有顺序关系?

答案是肯定有关系。
package > import > class
Package:只能有一个
import:可以有多个
class:可以有多个,以后建议是一个


今天我们就学到这里,明天我们来学习多态。

最后呢,欢迎有兴趣的同学加我朋友的QQ群:555974449
群主呢,也就是我在第一篇博客我毕业了中给大家提到的刘某人程序员
我们在群里等你!

版权声明:本文为博主原创文章,未经博主允许不得转载。

抽象类(abstract class)和接口(Interface)的区别

前言 抽象类(abstract class)和接口(Interface)是Java语言中对于抽象类定义进行支持的两种机制,赋予了Java强大的面向对象能力。二者具有很大的相似性,甚至可以相互替换,因...
  • aptentity
  • aptentity
  • 2017年04月01日 11:53
  • 1209

java接口(interface)与抽象类(abstract class)的区别

很久没有看到如此精辟的文章了!作者写得实在太好了!正在学JAVA或者想了解抽象类与接口的朋友,绝对不可错过!本人极力推荐! OOP中接口与抽象类的区别 Java语言接口与继承的本质 深入理解接口...
  • zgrjkflmkyc
  • zgrjkflmkyc
  • 2013年09月30日 21:08
  • 5861

安卓学习第十一天:抽象类,封装,包,访问权限

#1抽象函数与抽象类 只有函数定义,而没有函数体的函数就是抽象函数,使用abstract关键字来定义 Abstractvoid fun(); 在一个类当中,如果其中拥有一个或者一个以上的抽象函数...
  • sound2sd
  • sound2sd
  • 2015年04月25日 22:04
  • 414

Java接口,抽象类一些注意事项的总结

由于以前学习的C++中没有接口Interface的概念,所以对接口的一些特性不是很清楚,现在做一些总结。 首先从接口的定义开始 首先接口的访问权限:必须是public,而且默认是public,同样...
  • qq838642798
  • qq838642798
  • 2016年12月20日 11:49
  • 382

抽象类(abstract class)与接口(interface)的异同

抽象类:包含抽象方法的类就是抽象类 接口:指抽象方法的集合,方法不包含方法体相同点: 都不能被实例化 接口的实现类或者抽象类的子类都必须实现了接口或抽象类中的方法后才可以被实例化 不同点: 接口只有...
  • aym_fuhong
  • aym_fuhong
  • 2016年09月05日 20:07
  • 1712

Java之抽象(abstract)类、接口(interface)的用法总结

导读: 1、什么是抽象类(abstract)? 2、如何定义抽象类(abstract)? 3、抽象类(abstract)的作用? 4、何为接口?接口和类的区别? 5、怎么区分抽象类和接口? ...
  • dtjiawenwang88
  • dtjiawenwang88
  • 2017年06月14日 20:26
  • 519

继承原则与子父类初始化过程,类成员访问权限,普通类与抽象类,throwble类,重写与重载,string对象修改,i=i++;

Public>protected>default>private 以上是类成员访问权限及权限大小 2.继承原则和继承时初始化过程 子类继承父类的成员变量 子类继承父类除构造方法以外的成...
  • bird_tp
  • bird_tp
  • 2017年11月20日 22:18
  • 43

接口和抽象类的区别是什么?

接口和抽象类的区别是什么? 从设计层面来说,抽象是对类的抽象,是一种模板设计,接口是行为的抽象,是一种行为的规范。 接口中所有的方法隐含的都是抽象的。而抽象类则可以同时包含抽象和非抽象的方法。 ...
  • mumihahaha
  • mumihahaha
  • 2018年01月11日 16:33
  • 18

abstract修饰符 和 interface修饰符

==== abstract ======================================================================================...
  • DUANJIEFEI
  • DUANJIEFEI
  • 2015年06月04日 15:56
  • 853

抽象类abstract和接口interface的区别与深入思考

在以前的编程过程中,经常对abstract和interface混淆,相信很多初学者都有这样的困惑,也问过很多经验丰富的程序员,他们也不能清楚地说出个所以然来。经过自己的思考,想到了一种比较形象的方式来...
  • wujiaxian
  • wujiaxian
  • 2014年10月11日 11:32
  • 2785
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:JAVA基础再回首(七)——final关键字、抽象类abstract、接口interface、权限修饰符、导包
举报原因:
原因补充:

(最多只允许输入30个字)