1、接口概述与生活举例

接口就是一种公共的规范标准

只要符合规范标准,就可以大家通用

2、接口的定义基本格式

 public interface 接口名称 {    
  // 抽象方法     
// 默认方法    
// 静态方法     
// 私有方法
}

3、接口的抽象方法定义

package cn.itcast.day10.demo01;

/*
在任何版本的Java中,接口都能定义抽象方法。
格式:
public abstract 返回值类型 方法名称(参数列表); 注意事项:
1. 接口当中的抽象方法,修饰符必须是两个固定的关键字:public abstract
2. 这两个关键字修饰符,可以选择性地省略。(今天刚学,所以不推荐。)
3. 方法的三要素,可以随意定义。
*/
public interface MyInterfaceAbstract { // 这是一个抽象方法
public abstract void methodAbs1(); // 这也是抽象方法
abstract void methodAbs2(); // 这也是抽象方法
public void methodAbs3(); // 这也是抽象方法
void methodAbs4(); }

4、接口的抽象方法使用

alt+回车  显示所有抽象方法

package cn.itcast.day10.demo01;

public class MyInterfaceAbstractImpl implements MyInterfaceAbstract {
@Override
public void methodAbs1() {
System.out.println("这是第一个方法!");
} @Override
public void methodAbs2() {
System.out.println("这是第二个方法!");
} @Override
public void methodAbs3() {
System.out.println("这是第三个方法!");
} @Override
public void methodAbs4() {
System.out.println("这是第四个方法!");
}
}
package cn.itcast.day10.demo01;

/*
接口就是多个类的公共规范。
接口是一种引用数据类型,最重要的内容就是其中的:抽象方法。 如何定义一个接口的格式:
public interface 接口名称 {
// 接口内容
} 备注:换成了关键字interface之后,编译生成的字节码文件仍然是:.java --> .class。 如果是Java 7,那么接口中可以包含的内容有:
1. 常量
2. 抽象方法 如果是Java 8,还可以额外包含有:
3. 默认方法
4. 静态方法 如果是Java 9,还可以额外包含有:
5. 私有方法 接口使用步骤:
1. 接口不能直接使用,必须有一个“实现类”来“实现”该接口。
格式:
public class 实现类名称 implements 接口名称 {
// ...
}
2. 接口的实现类必须覆盖重写(实现)接口中所有的抽象方法。
实现:去掉abstract关键字,加上方法体大括号。
3. 创建实现类的对象,进行使用。 注意事项:
如果实现类并没有覆盖重写接口中所有的抽象方法,那么这个实现类自己就必须是抽象类。
*/
public class Demo01Interface { public static void main(String[] args) {
// 错误写法!不能直接new接口对象使用。
// MyInterfaceAbstract inter = new MyInterfaceAbstract(); // 创建实现类的对象使用
MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
impl.methodAbs1();
impl.methodAbs2();
} }

5、接口的默认方法的定义

6、接口的默认方法的使用

package cn.itcast.day10.demo01;

/*
从Java 8开始,接口里允许定义默认方法。
格式:
public default 返回值类型 方法名称(参数列表) {
方法体
} 备注:接口当中的默认方法,可以解决接口升级的问题。
*/
public interface MyInterfaceDefault { // 抽象方法
public abstract void methodAbs(); // 新添加了一个抽象方法
// public abstract void methodAbs2(); // 新添加的方法 ,改成默认方法
public default void methodDefault() {
System.out.println("这是新添加的默认方法");
} }
package cn.itcast.day10.demo01;

/*
1. 接口的默认方法,可以通过接口实现类对象,直接调用。
2. 接口的默认方法,也可以被接口实现类进行覆盖重写。
*/
public class Demo02Interface { public static void main(String[] args) {
// 创建了实现类对象
MyInterfaceDefaultA a = new MyInterfaceDefaultA();
a.methodAbs(); // 调用抽象方法,实际运行的是右侧实现类。 // 调用默认方法,如果实现类当中没有,会向上找接口
a.methodDefault(); // 这是新添加的默认方法
System.out.println("=========="); MyInterfaceDefaultB b = new MyInterfaceDefaultB();
b.methodAbs();
b.methodDefault(); // 实现类B覆盖重写了接口的默认方法
} }
package cn.itcast.day10.demo01;

public class MyInterfaceDefaultA implements MyInterfaceDefault {
@Override
public void methodAbs() {
System.out.println("实现了抽象方法,AAA");
}
}
package cn.itcast.day10.demo01;

public class MyInterfaceDefaultB implements MyInterfaceDefault {
@Override
public void methodAbs() {
System.out.println("实现了抽象方法,BBB");
} @Override
public void methodDefault() {
System.out.println("实现类B覆盖重写了接口的默认方法");
}
}

7、接口的静态方法的定义

static

8、接口的静态方法的使用

package cn.itcast.day10.demo01;

/*
注意事项:不能通过接口实现类的对象来调用接口当中的静态方法。
正确用法:通过接口名称,直接调用其中的静态方法。
格式:
接口名称.静态方法名(参数);
*/
public class Demo03Interface { public static void main(String[] args) {
// 创建了实现类对象
MyInterfaceStaticImpl impl = new MyInterfaceStaticImpl(); // 错误写法!
// impl.methodStatic(); // 直接通过接口名称调用静态方法
MyInterfaceStatic.methodStatic();
} }

9、接口的私有方法的定义

10、接口的私有方法的使用

package cn.itcast.day10.demo01;

public interface MyInterfacePrivateB {

    public static void methodStatic1() {
System.out.println("静态方法1");
methodStaticCommon();
} public static void methodStatic2() {
System.out.println("静态方法2");
methodStaticCommon();
} private static void methodStaticCommon() {
System.out.println("AAA");
System.out.println("BBB");
System.out.println("CCC");
} }
package cn.itcast.day10.demo01;

public class Demo04Interface {

    public static void main(String[] args) {
MyInterfacePrivateB.methodStatic1();
MyInterfacePrivateB.methodStatic2();
// 错误写法!
// MyInterfacePrivateB.methodStaticCommon();
} }

11、接口的常量定义和使用

package cn.itcast.day10.demo01;

/*
接口当中也可以定义“成员变量”,但是必须使用public static final三个关键字进行修饰。
从效果上看,这其实就是接口的【常量】。
格式:
public static final 数据类型 常量名称 = 数据值;
备注:
一旦使用final关键字进行修饰,说明不可改变。 注意事项:
1. 接口当中的常量,可以省略public static final,注意:不写也照样是这样。
2. 接口当中的常量,必须进行赋值;不能不赋值。
3. 接口中常量的名称,使用完全大写的字母,用下划线进行分隔。(推荐命名规则)
*/
public interface MyInterfaceConst { // 这其实就是一个常量,一旦赋值,不可以修改
public static final int NUM_OF_MY_CLASS = 12; }
package cn.itcast.day10.demo01;

public class Demo05Interface {

    public static void main(String[] args) {
// 访问接口当中的常量
System.out.println(MyInterfaceConst.NUM_OF_MY_CLASS);
} }

12、接口小结

13、继承父类并实现多个接口

package cn.itcast.day10.demo02;

public abstract class MyInterfaceAbstract implements MyInterfaceA, MyInterfaceB {
@Override
public void methodA() { } @Override
public void methodAbs() { } @Override
public void methodDefault() { } }

14、接口之间的多继承

15、多态的概述

extends和implements实现是多态性的前提。

16、多态的格式与使用

new的谁就用谁的方法

package cn.itcast.day10.demo04;

/*
代码当中体现多态性,其实就是一句话:父类引用指向子类对象。 格式:
父类名称 对象名 = new 子类名称();
或者:
接口名称 对象名 = new 实现类名称();
*/
public class Demo01Multi { public static void main(String[] args) {
// 使用多态的写法
// 左侧父类的引用,指向了右侧子类的对象
Fu obj = new Zi(); obj.method();
obj.methodFu();
}
}

17、多态中成员变量的使用特点

package cn.itcast.day10.demo05;

/*
访问成员变量的两种方式: 1. 直接通过对象名称访问成员变量:看等号左边是谁,优先用谁,没有则向上找。
2. 间接通过成员方法访问成员变量:看该方法属于谁,优先用谁,没有则向上找。
*/
public class Demo01MultiField { public static void main(String[] args) {
// 使用多态的写法,父类引用指向子类对象
Fu obj = new Zi();
System.out.println(obj.num); // 父:10
// System.out.println(obj.age); // 错误写法!
System.out.println("============="); // 子类没有覆盖重写,就是父:10
// 子类如果覆盖重写,就是子:20
obj.showNum();
} }
package cn.itcast.day10.demo05;

public class Fu /*extends Object*/ {

    int num = 10;

    public void showNum() {
System.out.println(num);
} public void method() {
System.out.println("父类方法");
} public void methodFu() {
System.out.println("父类特有方法");
} }
package cn.itcast.day10.demo05;

public class Zi extends Fu {

    int num = 20;

    int age = 16;

    @Override
public void showNum() {
System.out.println(num);
} @Override
public void method() {
System.out.println("子类方法");
} public void methodZi() {
System.out.println("子类特有方法");
}
}

18、多态中成员方法的使用特点

package cn.itcast.day10.demo05;

/*
在多态的代码当中,成员方法的访问规则是:
看new的是谁,就优先用谁,没有则向上找。 口诀:编译看左边,运行看右边。 对比一下:
成员变量:编译看左边,运行还看左边。
成员方法:编译看左边,运行看右边。
*/
public class Demo02MultiMethod { public static void main(String[] args) {
Fu obj = new Zi(); // 多态 obj.method(); // 父子都有,优先用子
obj.methodFu(); // 子类没有,父类有,向上找到父类 // 编译看左边,左边是Fu,Fu当中没有methodZi方法,所以编译报错。
// obj.methodZi(); // 错误写法!
} }

19、使用多态的好处

20、对象的向上转型

其实就是多态写法

21、对象的向下转型

package cn.itcast.day10.demo06;

/*
向上转型一定是安全的,没有问题的,正确的。但是也有一个弊端:
对象一旦向上转型为父类,那么就无法调用子类原本特有的内容。 解决方案:用对象的向下转型【还原】。
*/
public class Demo01Main { public static void main(String[] args) {
// 对象的向上转型,就是:父类引用指向之类对象。
Animal animal = new Cat(); // 本来创建的时候是一只猫
animal.eat(); // 猫吃鱼 // animal.catchMouse(); // 错误写法! // 向下转型,进行“还原”动作
Cat cat = (Cat) animal;
cat.catchMouse(); // 猫抓老鼠 // 下面是错误的向下转型
// 本来new的时候是一只猫,现在非要当做狗
// 错误写法!编译不会报错,但是运行会出现异常:
// java.lang.ClassCastException,类转换异常
Dog dog = (Dog) animal;
} }

22、用Instanceof关键字查找父类引用对象是什么子类

package cn.itcast.day10.demo06;

/*
如何才能知道一个父类引用的对象,本来是什么子类?
格式:
对象 instanceof 类名称
这将会得到一个boolean值结果,也就是判断前面的对象能不能当做后面类型的实例。
*/
public class Demo02Instanceof { public static void main(String[] args) {
Animal animal = new Dog(); // 本来是一只狗
animal.eat(); // 狗吃SHIT // 如果希望掉用子类特有方法,需要向下转型
// 判断一下父类引用animal本来是不是Dog
if (animal instanceof Dog) {
Dog dog = (Dog) animal;
dog.watchHouse();
}
// 判断一下animal本来是不是Cat
if (animal instanceof Cat) {
Cat cat = (Cat) animal;
cat.catchMouse();
} giveMeAPet(new Dog());
} public static void giveMeAPet(Animal animal) {
if (animal instanceof Dog) {
Dog dog = (Dog) animal;
dog.watchHouse();
}
if (animal instanceof Cat) {
Cat cat = (Cat) animal;
cat.catchMouse();
}
} }

23、笔记本综合案例

24、代码实现

package cn.itcast.day10.demo07;

public interface USB {

    public abstract void open(); // 打开设备

    public abstract void close(); // 关闭设备

}
package cn.itcast.day10.demo07;

// 鼠标就是一个USB设备
public class Mouse implements USB {
@Override
public void open() {
System.out.println("打开鼠标");
} @Override
public void close() {
System.out.println("关闭鼠标");
} public void click() {
System.out.println("鼠标点击");
}
}
package cn.itcast.day10.demo07;

// 键盘就是一个USB设备
public class Keyboard implements USB {
@Override
public void open() {
System.out.println("打开键盘");
} @Override
public void close() {
System.out.println("关闭键盘");
} public void type() {
System.out.println("键盘输入");
}
}
package cn.itcast.day10.demo07;

public class Computer {

    public void powerOn() {
System.out.println("笔记本电脑开机");
} public void powerOff() {
System.out.println("笔记本电脑关机");
} // 使用USB设备的方法,使用接口作为方法的参数
public void useDevice(USB usb) {
usb.open(); // 打开设备
if (usb instanceof Mouse) { // 一定要先判断
Mouse mouse = (Mouse) usb; // 向下转型
mouse.click();
} else if (usb instanceof Keyboard) { // 先判断
Keyboard keyboard = (Keyboard) usb; // 向下转型
keyboard.type();
}
usb.close(); // 关闭设备
} }
package cn.itcast.day10.demo07;

public class DemoMain {

    public static void main(String[] args) {
// 首先创建一个笔记本电脑
Computer computer = new Computer();
computer.powerOn(); // 准备一个鼠标,供电脑使用
// Mouse mouse = new Mouse();
// 首先进行向上转型
USB usbMouse = new Mouse(); // 多态写法
// 参数是USB类型,我正好传递进去的就是USB鼠标
computer.useDevice(usbMouse); // 创建一个USB键盘
Keyboard keyboard = new Keyboard(); // 没有使用多态写法
// 方法参数是USB类型,传递进去的是实现类对象
computer.useDevice(keyboard); // 正确写法!也发生了向上转型
// 使用子类对象,匿名对象,也可以
// computer.useDevice(new Keyboard()); // 也是正确写法 computer.powerOff();
System.out.println("=================="); method(10.0); // 正确写法,double --> double
method(20); // 正确写法,int --> double
int a = 30;
method(a); // 正确写法,int --> double
} public static void method(double num) {
System.out.println(num);
} }

Java(171-194)【接口、多态】的更多相关文章

  1. Java 面向对象之接口、多态

    01接口的概念 A:接口的概念 接口是功能的集合,同样可看做是一种数据类型,是比抽象类更为抽象的”类”. 接口只描述所应该具备的方法,并没有具体实现,具体的实现由接口的实现类(相当于接口的子类)来完成 ...

  2. Java面向对象(接口、多态)

    面向对象 今日内容介绍 u 接口 u 多态 第1章 接口 1.1 接口概念 接口是功能的集合,同样可看做是一种数据类型,是比抽象类更为抽象的”类”. 接口只描述所应该具备的方法,并没有具体实现,具体的 ...

  3. java基础(11):接口、多态

    1. 接口 1.1 接口概念 接口是功能的集合,同样可看做是一种数据类型,是比抽象类更为抽象的”类”. 接口只描述所应该具备的方法,并没有具体实现,具体的实现由接口的实现类(相当于接口的子类)来完成. ...

  4. Java基础第二天--多态、接口

    多态 多态的概述 同一个对象,在不同时刻表现出来的不同形态 多态的前提和体现 有继承/实现关系 有方法重写关系 有父类引用指向子类对象 public class Animal { public voi ...

  5. java:面向对象(多态,final,抽象方法,(简单工厂模式即静态方法模式),接口)

    * 生活中的多态:同一种物质,因环境不同而表现不同的形态. * 程序中多态:同一个"接口",因不同的实现而执行不同的操作. * 多态和方法的重写经常结合使用,子类重写父类的方法,将 ...

  6. 记录:JAVA抽象类、接口、多态

    JAVA抽象类.接口.多态 1. 多态 定义 多态是同一个行为具有多个不同表现形式或形态的能力.(多态就是同一个接口,使用不同的实例而执行不同操作) 如何实现多态 继承和接口 父类和接口类型的变量赋值 ...

  7. java提高篇之理解java的三大特性——多态

    面向对象编程有三大特性:封装.继承.多态. 封装隐藏了类的内部实现机制,可以在不影响使用的情况下改变类的内部结构,同时也保护了数据.对外界而已它的内部细节是隐藏的,暴露给外界的只是它的访问方法. 继承 ...

  8. Java调用webservice接口方法

                             java调用webservice接口   webservice的 发布一般都是使用WSDL(web service descriptive langu ...

  9. JAVA三大特性之多态

    面向对象的三大特性:封装.继承.多态.从一定角度来看,封装和继承几乎都是为多态而准备的.这是我们最后一个概念,也是最重要的知识点. 多态的定义:指允许不同类的对象对同一消息做出响应.即同一消息可以根据 ...

  10. Java三大特征之多态(三)

    面向对象编程有三大特性:封装.继承.多态. 封装隐藏了类的内部实现机制,可以在不影响使用的情况下改变类的内部结构,同时也保护了数据.对外界而已它的内部细节是隐藏的,暴露给外界的只是它的访问方法. 继承 ...

随机推荐

  1. IDEA 敏捷开发技巧——后缀完成

    前言 "工欲善其事,必先利其器." 所以说今天来看一看如何压榨 IDEA ,让你的 IDEA 使用的更顺手! 今日技巧: 后缀完成 自定义后缀完成模版 示例 上面动图使用了 .so ...

  2. Java Reference核心原理分析

    本文转载自Java Reference核心原理分析 导语 带着问题,看源码针对性会更强一点.印象会更深刻.并且效果也会更好.所以我先卖个关子,提两个问题(没准下次跳槽时就被问到). 我们可以用Byte ...

  3. eclipse中将项目加载到tocat报错:Tomcat version 6.0 only supports J2EE 1.2, 1.3, 1.4, and Java EE 5 Web modules

    第一种解决方法:只需要找到导入项目的配置文件即可,举个栗子:D:\公司\iptv_gx\iptv_gx\.settings\org.eclipse.wst.common.project.facet.c ...

  4. 后端程序员之路 18、朴素贝叶斯模型(Naive Bayesian Model,NBM)

    贝叶斯推断及其互联网应用(一):定理简介 - 阮一峰的网络日志http://www.ruanyifeng.com/blog/2011/08/bayesian_inference_part_one.ht ...

  5. MySQL提权 通过UDF

    目录 UDF是什么 命令执行 文本写入 Example: 远程写入 反弹Shell 提权 UDF是什么 参考:https://www.cnblogs.com/litlife/p/9030673.htm ...

  6. 500GJava/Hadoop/Spark/机器学习...视频教程免费分享 百度云持续更新

    参加工作这么长时间了,工作中遇到了不少技能都是看视频教程学习的,相比较看书而言看视频确实比较容易理解.分享一下自己看过的和收集的视频教程. 资源包括: 大数据方面的Hadoop(云帆,小象学院,八斗学 ...

  7. (数据科学学习手札110)Python+Dash快速web应用开发——静态部件篇(下)

    本文示例代码已上传至我的Github仓库https://github.com/CNFeffery/DataScienceStudyNotes 1 简介 这是我的系列教程Python+Dash快速web ...

  8. 每日一题20201112(922. 按奇偶排序数组 II)

    题目链接: 922. 按奇偶排序数组 II 思路 很简单,搞懂问题的核心就行,假设现在有奇数在偶数位上,偶数在奇数位上. 那么我们要做的就是,找到分别在对方位置上的数字,然后交换他们就行. class ...

  9. python3中post和get请求处理

    post 请求处理 def url(): url = "www.xxx.com.cn" data = { "csrfmiddlewaretoken":" ...

  10. python学习总结篇(2)——函数

    如其他语言一样,除了基本知识外,另外一个重要的板块就是函数了,python中也有函数. 在python中,函数的定义方式为: def   函数名( ): 下面通过几个简单的例子,看看python中的函 ...