Java面向对象编程——抽象类和接口

Java面向对象编程——抽象类和接口
定义类的过程就是抽象和封装的过程，而抽象类与接口则是对实体类进行更高层次的抽象，进定义公共行为和特征。

抽象类：
如果一个类没有足够的信息去描述一个具体的对象，那我们就称之为抽象类。

语法格式:

public abstract class 类名{}

案例代码:

package Demo01;/*** @version 1.0* @author: weimengjie* @date: 2021-05-13 10:31*/
public class Demo01 {// 定义动物抽象类public abstract  class Animal{}
}

抽象方法：

有了抽象类，类中就要有与之对应的抽象方法。抽象发发就是用abstract修饰的方法，这种方法值声明返回的数据类型，方法名称和所需要的参数，没有方法体。也就是说在抽响雷中声明抽象方法时，值需要声明方法，不需要定义方法体。子类在继承父类时，必须重写父类的抽象方法，这也是抽象方法存在的意义。

语法格式:

public abstract 返回值类型 方法名（参数列表）；

案例代码：

package Demo01;/*** @version 1.0* @author: weimengjie* @date: 2021-05-13 10:31*/
public class Demo01 {// 定义动物抽象类public abstract  class Animal{public abstract void go(); //  名为go的抽象方法，注意方法没有大括号}
}

抽象类和抽象方法具体该怎么使用？抽象方法的作用是什么？

案例代码:

package Demo01;/*** @version 1.0* @author: weimengjie* @date: 2021-05-13 10:31*/
public class Demo01 {// 定义动物抽象类public abstract  class Animal{public abstract void go(); //  名为go的抽象方法，注意方法没有大括号}public class Demo02 extends Demo01 {public void go(){System.out.println("鸟飞的块");}}public class Demo03 extends Demo01{public void go(){System.out.println("狗跑的块");}}
}

测试类：

package Demo01;/*** @version 1.0* @author: weimengjie* @date: 2021-05-13 10:42*/
public class Demo04 {public static void main(String[] args) {Demo02 d = new Demo02();d.go();Demo03 demo03 = new Demo03();demo03.go();}
}

通过上面的代码我们可以总结：

定义抽象类就是用于继承的。和一般类的继承相比，子类继承抽象类必然会实现抽象方法。由于抽象方法都是没有方法体的，也就是说，抽象方法并没有写死，我么可以根据自己的需求去写

抽象类是一种模板式设计，通常是对同类事物相对具体的抽象。抽象类通常包含抽象方法、实体方法、属性变量。。我们在使用抽象方法和抽象类时，需要注意以下几点。

（1）包含抽象方法的类一定时抽象类。

（2）抽象类中的方法不一定都是抽象方法。抽象类也可以没有抽象方法

（3）构造方法不能声明为抽象方法

（4）abstract 不能与private 、static、final、native并修饰同一个方法

final修饰符
使用：

显示生活中，我们的身份证一经确定，身份证号就不能在此修改了。那我们Java中某些数据是定值，为了保证计算的正确性，不能在被修改，应该怎末办呢？这时候就用到了final修饰符，表示最终的。

final使用有以下几种情况。
（1）修饰类

（2）修饰方法

（3）修饰对象和变量

修饰类：
被final修饰过的类不能被继承

.因为不能被继承，所以此类中的所有方法默认都是final修饰

该类如果不需要子类，不需要被扩展，类中的方法不允许被重写，就是用final

修饰方法：
被final修饰的方法可以被继承，不能被覆盖重写

修饰对象和变量：
final修饰一个对象，那么这个对象的引用不能变，但是值是可以变的。如果是基础类型，那么值不可变。

案例代码：

package Demo02;;/*** @version 1.0* @author: weimengjie* @date: 2021-05-13 10:31*/
public class Demo01 {public String name;public Demo01(String name) {super();this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "Demo01{" +"name='" + name + '\'' +'}';}
}

测试类：

package Demo02;/*** @version 1.0* @author: weimengjie* @date: 2021-05-13 10:31*/
public class Demo02 {public static void main(String[] args) {// final 修饰的是李斯特这个对象final Demo01 list  = new Demo01("李四");// 李四对象中name 属性并没有被final修饰list.setName("张三");//最终输出内容：Demo01{name='张三'}System.out.println(list.toString());}
}

接口
在生活中，接口时一套规范，满足这个规范的设备，就可以组装在一起。

接口就像插座一样，一种插孔可以插很多种电器，这个插孔就是我们像外卖呢提供的接口，所有的电器都要实现这个接口

为什么需要接口？

和抽象类对同类事物进行抽象不同，接口不是类，而是一组对类的需求描述（可以看成只有抽象方法的抽象类）。这要求接口采用锲约式、开放式对需求进行设计，这样才能满足不同事物的相同要求。

接口的使用
在软件中，接口同样是一种规范和标准，他们可以约束类的行为，是一些方法特征的集合，但没有方法的实现，需要类对接口进行实现。

Java中接口的定义语法：

[修饰符] interface 接口名 extends 父接口1，父接口2 ..{// 常量定义// 方法定义
}

类实现接口的语法如下:

class 类名 extends父类名 implement  接口1 ，接口2 ，，，{//类成员
}

interface 之中可以定义变量和方法，变量必须是public static final的，方法必须是public 、abstract的

说明：

（1）接口的命名规则与类相同。如果修饰符是public，则该接口在整个项目中可见；如果省略修饰符，则该接口只在当前包可见。

（2）接口中可以定义常量，不能定义变量。接口中的属性都会自动用public static final 修饰

（3）接口中的所有方法都是抽象方法。接口中方法都会自动用 public abstract修饰，即接口中只有全局抽象方法

（4）和抽象类一样，接口也不能实例化，接口中不饿能有构造方法

（5）接口之间可以通过extends来实现继承关系，一个接口可以继承多个接口，但接口不能继承类。

(6)实现接口的类必须实现接口的全部方法，否则必须定义为抽象类

（7）一个类只能有一个直接父类，但可以通过implements是西安多个接口。当类在继承父类的同时有实现了多个接口时，extends关键字必须位于implements 关键字之前

案例代码：

（1）约定Usb接口标准

（2）制作符合Usb接口约定的各种具体设备

（3）将Usb设备插到Usb接口上进行工作

package Demo03;/**
*@author: weimengjie
*@date:  2021-05-14 09:08
*@version 1.0
*/public abstract class Demo01 {public interface Usb{public void run();}static class UsbPrinter implements Usb{@Overridepublic void run(){System.out.println("Usb连接中，打印机连接中，开始工作");}}static class UsbMouse implements  Usb{@Overridepublic void run(){System.out.println("Usb 连接中 ，鼠标连接中，开始工作");}  }static class Test{public static  void main(String[] args){Usb a = new UsbPrinter();Usb B = new UsbMouse();a.run();B.run();}}
}

接口是一种能力使用
接口是一种能力，一个类实现了某个接口，就表示这个类具备了某种能力。

案例代码：

package Demo03;import org.w3c.dom.ls.LSOutput;/*** @version 1.0* @author:weimengjie* @date: 2021-05-14 09:24*/
public class Demo02 {static  public abstract class Venicle {public abstract void run();public abstract void stop();}static  interface Lock {void lock();void open();}static class Car extends Venicle implements Lock{@Overridepublic void run() {System.out.println("开完锁，发动引擎，驾驶员驾驶者汽车开始行驶");}@Overridepublic void stop() {System.out.println("驾驶员将发动机熄火，准备锁上汽车");}@Overridepublic void lock() {System.out.println("插进钥匙，向左旋转三圈，拔出钥匙");}@Overridepublic void open() {System.out.println("插进钥匙，向右旋转三圈，所打开了，拔出钥匙");}}
}

测试类：

package Demo03;/*** @version 1.0* @author:weimengjie* @date: 2021-05-14 09:41*/
public class TestDemo02 {public static  void main(String[] args){Demo02.Car  car = new Demo02.Car();car.lock();car.open();car.run();car.stop();}
}

既然接口代表一种能力，那么我i们在开车和停车的基础上，扩展行车记录仪记录功能，需要增加一种能力

代码：

package Demo03;/*** @version 1.0* @author:weimengjie* @date: 2021-05-14 09:24*/
public class Demo03 {static  public abstract class Venicle {public abstract void run();public abstract void stop();}interface Lock {void lock();void open();}interface TripREC{void record();}static class Car extends Venicle implements Lock{@Overridepublic void run() {System.out.println("开完锁，发动引擎，驾驶员驾驶者汽车开始行驶");}@Overridepublic void stop() {System.out.println("驾驶员将发动机熄火，准备锁上汽车");}@Overridepublic void lock() {System.out.println("插进钥匙，向左旋转三圈，拔出钥匙");}@Overridepublic void open() {System.out.println("插进钥匙，向右旋转三圈，所打开了，拔出钥匙");}public void record(){System.out.println("行车记录仪开始录像");}}
}

测试类:

package Demo03;/*** @version 1.0* @author:weimengjie* @date: 2021-05-14 09:41*/
public class TestDemo03 {public static  void main(String[] args){Demo03.Car  car = new Demo03.Car();car.lock();car.open();car.run();car.stop();car.record();}
}

从结果中可以看出：

接口在代码的扩展和维护方面十分方柏霓。接口类似于一个组件，需要时可以自由组装。从使用角度来讲，接口和抽象类的区别在于：抽象类利于代码复用，接口利于代码维护

接口是一种约定
接口其实就是一种约定，实现接口的类就必须遵守这个接口的约定

Java8中接口的变化
在 JDK 8及以后，允许我们在接口中定义static方法和default方法，这两种方法可以有方法体

default方法属于实例，static方法属于接口或类。要注意的是 default方法可以被继承，static方法不能被继承

如果一个类实现了多个接口，并且这些接口之间没有相互继承关系，同时存在相同的default方法时会报错，不过可以在实现类中重写default方法并通过“<接口>.super.<方法名>();"
静态方法：
在接口中增加静态方法。理论上讲。没有任何理由认为这是不合法的。只是这有违将接口作为抽象规范的初衷

案例代码：

package Demo04;/*** @version 1.0* @author:weimengjie* @date: 2021-05-14 10:02*/
public class Demo01 {public static void main(String[] args) {//静态方法不会被继承TestInter.staticMethh();TestInter2.staticMethh2();}
}interface TestInter{static void staticMethh(){System.out.println("TestInter中的静态方法");}
}
interface TestInter2{static void staticMethh2(){System.out.println("TestInter2中的静态方法");}
}

默认方法：
default关键字修饰接口的方法，使其称为默认方法。目的时减少子类实现接口的工作量。

案例代码：

先看没有使用默认方法的方式：

package Demo04;/*** @version 1.0* @author: weimengjie* @date: 2021-05-14 10:18*/
public class Demo02 {public interface Log {void login(String name);}class Emp implements Log{@Overridepublic void login(String name){System.out.println("用户"+name+":登陆系统");}}class Student implements  Log{@Overridepublic void login(String name){System.out.println("用户"+name+";登陆系统");}}
}

再看使用默认方法之后的代码：

package Demo04;/*** @version 1.0* @author:weimengjie* @date: 2021-05-14 10:21*/
public class Demo03 {public interface Log{default  void login(String name){System.out.println("用户"+name+":登陆系统");}}static class Emp implements Log{}static class Student implements Log{}static class DefaultMethodTest{public static void main(String[] args) {Emp emp = new Emp();emp.login("张三");Student student = new Student();student.login("李四");}}
}

结论：

如果多个子类实现某个接口方法，方法体都是一样的，这就导致后期维护上的困难，如果在接口中定义了默认的实现，那么即减少了子类实现的接口的工作量，也为后期的维护提供了方便（只需要更改接口中的默认实现即可）

总结
面向接口编程可以实现接口和现实的分离，这样做最大的好处就是能够在客户端位置的情况下修改是西安代码，那么怎样抽象出接口呢？一种时用在层与层的调用。层与层之间最机会耦合度过高或修改过于频繁。设计优秀的接口能够解决这个问题，

另一种时是使用在那些不稳定的部分上。如果某些需求的变化性很大，那么定义接口也是一种解决方法，设计良好的接口就像日常使用的万能插座，不论插头如何变化，都可以使用

当纠结定义接口还是抽象类时，优先推荐定义为接口，遵循接口隔离原则，按某个维度划分成多个接口，然后在用抽象类去是实现某些接口，这样做可方柏霓后续的扩展和重构。

Java面向对象编程——抽象类和接口相关推荐

Java面向对象编程篇3——接口与抽象类
Java面向对象编程篇3--接口与抽象类 1.接口(interface) 接口中可以含有变量和方法.但是要注意,接口中的变量会被隐式地指定为public static final变量(并且只能是pub ...
Java自学笔记——Java面向对象——04.抽象类、接口、内部类
Java 面向对象各节 Java自学笔记--Java面向对象--01.回顾方法 Java自学笔记--Java面向对象--02.构造器.类和对象 Java自学笔记--Java面向对象--03.封装.继承 ...
Java面向对象之抽象类与接口
Java面向对象之抽象类与接口 ⚡️前言⚡️ 本篇文章为面向对象部分的第三篇文章,前两篇文章见链接包和继承.组合与多态.抽象类和接口都是继承关系中父类的更进一步,结合前两篇文章来阅读更易理解掌握.
Java面向对象(2).抽象类和接口
抽象类(abstract没有足够的信息来描述) 被abstract修饰的类就是抽象类,修饰的方法就是抽象方法. 抽象类中可以没有抽象方法,但有抽象方法的类必须要声明为抽象类. 抽象类不能使用new来创 ...
Java面向对象程序设计(抽象类和接口-----)
接口在Java语言中,仅支持单一继承,即一个子类只能有一个直接的父类,然而在日常生活中,多继承的问题在所难免如电子书既是一种图书,同时又是一种多媒体,这种继承关系要求子类继承多个父类.这样就可能导 ...
java面向对象编程_包_继承_多态_重载和重写_抽象类_接口_this和super
目录点击跳转包包的命名方法导入包中的类系统包的介绍 **注意事项** 继承基础知识构造方法 **基础语法** `protected`修饰符组合 `this`和`super`关键字 `th ...
为什么有人说面向对象编程就是面向接口编程?
"面向对象编程就是面向接口编程" 这句话相信, 很多人都在网上见过, 装b利器. 我一开始也是这么想的, 那些装b者丢下这一句, 就没下文了. 首先, 我认为这句话是1个假命题. ...
java面向对象编程知识点总结
一:今天完成上午详细了解了java面向对象编程的一些细节,记录如下. 1)类是一种引用类型,包含一个签名和一个主体,主体是放在花括号里面的成员,成员包括字段和方法,还有构造方法.初始化程序和嵌套类 ...
Java提高篇 —— 抽象类与接口
一.前言接口和内部类为我们提供了一种将接口与实现分离的更加结构化的方法. 抽象类与接口是java语言中对抽象概念进行定义的两种机制,正是由于他们的存在才赋予java强大的面向对象的能力.他们两者之间 ...

Java面向对象编程——抽象类和接口

Java面向对象编程——抽象类和接口相关推荐

最新文章

热门文章