JAVA之旅（七）——final关键字 , 抽象类abstract，模板方法模式，接口interface，implements，特点，扩展-低调大师

JAVA之旅（七）——final关键字 , 抽象类abstract，模板方法模式，接口interface，implements，特点，扩展

2018-04-03 678

JAVA之旅（七）——final关键字 , 抽象类abstract，模板方法模式，接口interface，implements，特点，扩展

一.final

我们来聊聊final这个关键字

final可以修饰类，方法和变量
final修饰的类不可以被继承
final修饰的方法不可以被覆盖
final修饰的变量是一个常量，只能被赋值一次
内部类只能访问被final修饰的局部变量

final，故名思意，就是最终的意思，由以上的五种特性，不过final的出现，也是有弊端的，他破坏了封装性，对继承有了挑战，为了避免被继承，被子类复写功能，还有，当你描述事物时，一些数据的出现值是固定的，那么，这时为了增强阅读行，都给这个值起个名字方便阅读，而这值不需要改变，就会用到final去修饰，作为常量，常量的书写规范是所有字母都大写，如果由多个单词组成，单词间通过下划线链接！而且内部类定义在类中的局部位置只能访问该局部被final修饰的局部变量

final大家只要记住他的特性就行

二.抽象类

这个抽象类应该是属于继承的下半部分的，我们看一个标注的代码

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {

    }
}

/**
 * 学生
 * 
 * @author LGL
 *
 */
class student extends Base {

    void speak() {
        System.out.println("学习");
    }
}

/**
 * 工人
 * 
 * @author LGL
 *
 */
class worker extends Base {

    void speak() {
        System.out.println("工作");
    }
}

/**
 * 基类
 * 
 * @author LGL
 *
 */
class Base {

    void speak() {
        System.out.println("Hello");
    }
}

这里，学生和工人都是要说话，所以我们可以抽取，但是这里，他们说话的内容却是不同的，当多个类出现相同功能，但是功能主体不同，这个时候就可以进行向上抽取，这时只抽取功能主体；这个时候就得用到我们的抽象类了abstract；所以我们的基类是这样的

/**
 * 基类
 * 
 * @author LGL
 *
 */
abstract class Base {

    abstract void speak();
}

什么叫抽象？

看不懂

特点

1.抽象方法一定定义在抽象类中
2.抽象方法和抽象类都必须被abstract关键字修饰
3.抽象类不可以用new创建对象，因为调用抽象方法没意义
4.抽象类中的方法要被使用必须由子类复写其所有的抽象方法后建立子类对象调用
- 如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类

其实抽象类和一般的类没有什么太大的不同，只是要注意该怎么描述事物就怎么描述事物，只不过该事物中出现了一些看不懂的东西，这些不确定的部分也是该事物的功能，需要明确出来，但是无法定义主体，通过抽象方法来表示！

抽象类比其他类多了抽象函数，就是在类中可以定义抽象方法
抽象类不可以实例化

特殊：抽象类中可以不顶用抽象方法，看上去很没有意义，但是这样做可以做到不让该类建立对象，不是很多见

抽象方法文字部分说了这，多，我们做一个小练习

题目：假如我们在开发一个系统时需要对员工进行建模，员工包含三个属性姓名，工号和工资，经理也是员工，除了含有员工的属性外，另外还有一个奖金属性，请使用继承的思路设计出员工类和经理类，要求类种提供必要的方法进行属性访问！

我们实现之前可以简单的分析一下，我们的员工类应该有三个属性，name,id,pay，而经历类，理论上是继承了员工类并且有资金的奖金属性，行，这样的话我们可以用代码去测试一下

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {

        /**
         * 假如我们在开发一个系统时需要对员工进行建模，员工包含三个属性 姓名，工号和工资，经理也是员工，除了含有员工的属性外，另外还
         * 有一个奖金属性，请使用继承的思路设计出员工类和经理类，要求类 种提供必要的方法进行属性访问！
         */
    }
}

/**
 * 员工类
 * 
 * @author LGL
 *
 */
abstract class Employee {
    // 姓名
    private String name;
    // 工号
    private String id;
    // 工资
    private double pay;

    // 这个员工一生成，这三个属性必须有
    public Employee(String name, String id, double pay) {
        this.name = name;
        this.id = id;
        this.pay = pay;
    }

    // 员工做什么是不确定的
    public abstract void work();

}

/**
 * 经理类
 * 
 * @author LGL
 *
 */
class Manager extends Employee {

    // 奖金
    private int bonus;

    public Manager(String name, String id, double pay, int bonus) {

        super(name, id, pay);
        this.bonus = bonus;
    }

    // 复写
    @Override
    public void work() {
        System.out.println("管理");
    }

}

这代码很清晰的就表现了抽象的关系

三.模板方法模式

这是一个小案例，获取一段程序的运行时间，这个需求应该很简单吧，计时，

原理：获取程序开始和结束的时间并相减

获取时间的方法：System.currentTimeMillis()

代码逻辑是这样写的

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {

        GetTime gt = new GetTime();
        gt.getTime();
    }
}

/**
 * 时间类
 * 
 * @author LGL
 *
 */
class GetTime {
    // 获取时间
    public void getTime() {
        long start = System.currentTimeMillis();
        // 耗时
        for (int i = 0; i < 10000; i++) {
            System.out.print("" + i);
        }
        long end = System.currentTimeMillis();
        System.out.println("耗时：" + (end - start));
    }
}

我们就可以得到你代码运行的毫秒数了

但是我们发现，其实这个耗时的部分是不确定的，对吧，那既然这样，我们复写的话，就有点多余了，我们可以使用使用模板方法模式，也就是抽成一个方法公用

import org.ietf.jgss.Oid;

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {

        GetTime gt = new GetTime();
        gt.getTime();
    }
}

/**
 * 时间类
 * 
 * @author LGL
 *
 */
class GetTime {
    // 获取时间
    public void getTime() {
        long start = System.currentTimeMillis();

        runCode();

        long end = System.currentTimeMillis();
        System.out.println("耗时：" + (end - start));
    }

    /**
     * 耗时方法
     */
    private void runCode() {
        // 耗时
        for (int i = 0; i < 10000; i++) {
            System.out.print("" + i);
        }
    }
}

这个时候，要是其他类想使用的话，就只要复写一个方法就行了，Test想使用的话，就可以直接继承复写了

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {

        // GetTime gt = new GetTime();
        Test t = new Test();
        t.getTime();
    }
}

/**
 * 时间类
 * 
 * @author LGL
 *
 */
class GetTime {
    // 获取时间
    public void getTime() {
        long start = System.currentTimeMillis();

        runCode();

        long end = System.currentTimeMillis();
        System.out.println("耗时：" + (end - start));
    }

    /**
     * 耗时方法
     */
    public void runCode() {
        // 耗时
        for (int i = 0; i < 10000; i++) {
            System.out.print("" + i);
        }
    }
}

class Test extends GetTime {
    @Override
    public void runCode() {
        // 耗时
        for (int i = 0; i < 50000; i++) {
            System.out.print("" + i);
        }
    }
}

这样，输出的内容就是我们随便改的了

我们还可以用抽象去做，你就一定要去做这件事儿

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {

        // GetTime gt = new GetTime();
        Test t = new Test();
        t.getTime();
    }
}

/**
 * 时间类
 * 
 * @author LGL
 *
 */
abstract class GetTime {
    // 获取时间
    public void getTime() {
        long start = System.currentTimeMillis();

        runCode();

        long end = System.currentTimeMillis();
        System.out.println("耗时：" + (end - start));
    }

    /**
     * 耗时方法
     */
    public abstract void runCode();
}

class Test extends GetTime {
    @Override
    public void runCode() {
        // 耗时
        for (int i = 0; i < 50000; i++) {
            System.out.print("" + i);
        }
    }
}

我把这个延时的操作留给子类，你爱咋地就咋滴，这样是不是更方便？当然，我们可以给getTime加一个final修饰，这样就让程序更加的健壮；

当代码完成优化之后，就可以解决这类问题了，我们把这种方式叫做：模板方法设计模式

什么是模板方法？

在定义功能的时候，功能的一部分是不确定的，而确定的部分在使用不确定的部分的时候，那么这时就将不确定的部分暴露出去让子类去完成，这就是吗，吗，模板方法模式了

四.接口

接口的关键字是interface，接口中的成员修饰符是固定的

成员常量：public static final
成员函数：public abstract

接口的出现将“多继承”通过另一种形势体现，即“多实现”

上面的都是概念。我还是通俗易懂的来说吧，接口，初期理解，你可以认为是一个特殊的抽象类，当抽象类中的方法都是抽象的，那么该类可以通过接口的形式表示，interface，class用于定义类，定义接口

接口定义时，格式特点在于
- 1.接口中常见的定义一个是常量，一个是抽象方法
- 2.接口中的成员都有固定修饰符
- 常量：public static final
- 方法：public abstract

具体格式：

/**
 * 人的接口
 * 
 * @author LGL
 *
 */
interface Person {

    public static final int AGE = 20;

    /**
     * 说话
     */
    public abstract void speak();
}

这里注意，接口中的成员都是public，我们要想使用这个接口，需要用到另一个关键字了implements

为什么我们类不能继承类呢？因为接口，是不可以创建对象的，因为有抽象方法，需要被子类去实现，子类对接口中的抽象方法全都覆盖过后子类才可以实例化，否则子类是一个抽象类

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {

        Student s = new Student();
        System.out.println(s.AGE);
        System.out.println(Student.AGE);
        System.out.println(Person.AGE);
    }
}

class Student implements Person {

    @Override
    public void speak() {

    }

}

/**
 * 人的接口
 * 
 * @author LGL
 *
 */
interface Person {

    public static final int AGE = 20;

    /**
     * 说话
     */
    public abstract void speak();
}

这样执行的后，我们就等得到数据了

不过接口不仅仅是这么简单，接口是可以被类多实现了，什么叫做多实现？就是一个类单继承，但是可以实现多个接口，对继承不支持的形式，java支持多实现

class Student implements Person, Person2 {

    @Override
    public void speak() {

    }

    @Override
    public void work() {

    }

}

/**
 * 人的接口
 * 
 * @author LGL
 *
 */
interface Person {

    public static final int AGE = 20;

    /**
     * 说话
     */
    public abstract void speak();
}

interface Person2 {
    public abstract void work();
}

可以看到实现了；两个接口，但是他为什么没有继承的弊端呢？因为他没有方法主体，子类爱怎么着就怎么着了

接口间的关系时继承

接口的特点

这个接口的重点比较实在，所以单独提取出来讲一下，首先我们来连接一下接口的特点

接口谁对外暴露的规则
接口是程序的功能扩展
接口可以用力多实现
类和接口之间是实现关系，而且类可以继承一个类的同时实现多个接口
接口与接口之间可以有继承关系

就好比笔记本，我们扩展一样，这就是接口的概念，说不如做，我们写个例子来展现：

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {

    }
}

/**
 * 学生类
 * 
 * @author LGL
 *
 */
abstract class Student {
    // 学习不确定
    abstract void study();

    // 都要睡觉
    void Sleep() {
        System.out.println("sleep");
    }
    //都抽烟
    abstract void smoke();
}

/**
 * 我
 * @author LGL
 *
 */
class lgl extends Student{

    @Override
    void study() {
        System.out.println("lgl学习");
    }

    @Override
    void smoke() {
        System.out.println("lgl 抽烟");
    }

}

我这里定义了一个人，他有抽烟，睡觉，学习的方法，学习的方法不确定，所以要抽象，睡觉都要，抽烟，有的人抽，有的不抽，品牌也不一样，所以也得弄成这样，现在我去继承这个人，机会有学习和睡觉的方法，但是强制性的抽烟了，这就是这个例子的问题，那我们要怎么改善？还得使用接口了，我们可以把抽烟的方法抽写成接口，有需要接实现这个接口

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {
        lgl l = new lgl();
        l.smoke();
        l.study();
    }
}

/**
 * 学生类
 * 
 * @author LGL
 *
 */
abstract class Student {
    // 学习不确定
    abstract void study();

    // 都要睡觉
    void Sleep() {
        System.out.println("sleep");

    }
}

/**
 * 我
 * 
 * @author LGL
 *
 */
class lgl extends Student implements smoke{

    @Override
    void study() {
        System.out.println("lgl学习");
    }

    @Override
    public void smoke() {
        System.out.println("lgl 抽烟");
    }

}
/**
 * 抽烟的接口
 * @author LGL
 *
 */
interface smoke {
    void smoke();
}

这样就可以输出

好的，我们本篇幅就先到这里，如果有不明白的地方，还是要多温习几遍哦，想学好android，java功底是必不可少的呢！

原文地址http://www.bieryun.com/2716.html

微信关注我们

原文链接：https://yq.aliyun.com/articles/576014

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

初学Python—列表和元组

一、什么是列表列表是一系列数据的集合二、列表的引用首先定义一个列表 1 names=["alex","bob","alice","jim"] View Code 列表引用： name[0] name[1] print(name[3]) View Code 三、列表操作 1.查询列表元素 ①利用下标输出列表元素 print(names[0]) #输出列表第一个元素 print(names[0:5]) #输出列表前五个元素（顾头不顾尾） print(names[-1]) #输出列表最后一个元素 print（names[-4:-1]）#输出列表倒数第四个至倒数第二个元素的值（顾头不顾尾） print（names[-3:0]）#输出列表最后三个元素print(nemas[::3]) #从第一个元素开始，每三个元素输出一个（隔两个元素输出一个元素） ②查找元素所在位置：index方法 print(names.index("alex")) #查找元素“alex”的下标，输出为0 ③统计相同元素的个数：count方法 print(names.count("alex")) #输出“alex”元素...

2018-04-03

718

JAVA之旅（八）——多态的体现，前提，好处，应用，转型，instanceof，多态中成员变量的特点，多态的案例一.多态我们今天又要学习一个新的概念了，就是多态，它是面向对象的第三个特征，何谓多态？定义某一类事物的多种存在方式比如动物中的猫狗，人类中的男人，女人我们可以把多态理解为事物存在的多种体现形态当我们new一个猫类的时候，和new 一个动物，其实是一样的，多种形态变现所以我们可以分这几部分分析多态的体现多态的前提 3.多态的好处 4.多态的应用我们定义一个需求，描述动物，正常的逻辑应该是这样描述的 //公共的类类名 public class HelloJJAVA { // 公共的静态无返回值 main方法数组 public static void main(String[] str) { /** * 动物：猫，狗 */ Cat c = new Cat(); c.eat(); dog d = new dog(); d.eat(); } } /** * 动物 * * @author LGL * */ abstract class Animal {...

2018-04-03

641

资源下载

更多资源

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。

WebStorm

WebStorm 是jetbrains公司旗下一款JavaScript 开发工具。目前已经被广大中国JS开发者誉为“Web前端开发神器”、“最强大的HTML5编辑器”、“最智能的JavaScript IDE”等。与IntelliJ IDEA同源，继承了IntelliJ IDEA强大的JS部分的功能。