Java语言入门||02_面向对象与常用类||day10_接口，多态
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了Java语言入门||02_面向对象与常用类||day10_接口，多态，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含14692字，纯文字阅读大概需要21分钟。
内容图文
第一章 接口
1.1 接口概述和生活举例
- 接口就是一种公共的规范标准
- 只要符合规范标准，就可以大家通用
- 只要符合规范标准，就可以大家通用
1.2 接口的定义基本格式
- 接口是一种引用数据类型，最重要的内容就是其中的：抽象方法。
- 定义一个接口的格式：
public interface 接口名称{ //接口内容 }
-
注：换成了关键字interface之后，编译生成的字节码文件仍然是：.java–>.class
-
接口包含如下：
- 如果是Java 7， 那么接口中可以包含的有：
- 常量
- 抽象方法
- 如果是Java 8， 那么接口中额外包含的有：
3. 静态方法
4. 默认方法 - 如果是Java 9， 那么接口中额外包含的有：
5. 私有方法
1.3 接口的抽象方法定义
- 在任何版本的Java中，接口都能定义抽象方法：（没有方法体）
//格式： public abstract 返回值类型 方法名称（参数列表）;
- 注意事项：
- 接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
- 这两个关键字修饰符，可以选择性的省略。
- 方法三要素，可以随意定义
public interface MyInterfaceAbstract {
//都是抽象方法
public abstract void methodAbs();
abstract void methodAbs1();
public void methodAbs2();
void methodAbs3();
}
1.4 接口的抽象方法使用
- 接口使用步骤：
- 接口不能直接使用，必须有一个实现类来实现接口。
//格式： public class 实现类名称 implements 接口名称{ // ... } - 接口的实现类必须覆盖重写（实现）接口中所有的抽象方法
- 实现：去掉abstract关键字，加上方法体大括号
- 创建实现类的对象，进行使用
- 不能直接new接口对象使用
- 创建名字：接口名+Impl（软性要求）
- 注意事项：
- 如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类
//定义了一个接口：MyInterfaceAbstract.java public interface MyInterfaceAbstract { //都是抽象方法 public abstract void methodAbs(); abstract void methodAbs1(); public void methodAbs2(); void methodAbs3(); } //定义了一个实现类：MyInterfaceAbstractImpl.java public class MyInterfaceAbstractImpl implements MyInterfaceAbstract{ @Override public void methodAbs() { System.out.println("这是第一个方法"); } @Override public void methodAbs1() { System.out.println("这是第二个方法"); } @Override public void methodAbs2() { System.out.println("这是第三个方法"); } @Override public void methodAbs3() { System.out.println("这是第四个方法"); } } //主方法：Demo01Interface.java public static void main(String[] args) { //错 //MyInterfaceAbstract inter = new MyInterfaceAbstract(); MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl(); impl.methodAbs(); impl.methodAbs1(); }
1.5 接口的默认方法定义(Java 8)
- 从Java 8开始，接口里允许定义默认方法:（有方法体）
//格式： public default 返回值类型 方法名称(参数列表){ 方法体; }
- 注：接口当中的默认方法，可以解决接口升级问题(今后课程中：Lambda表达式和函数式编程时候—>接口默认方法可以拼接函数模型)
- 原来接口只有一个抽象方法，拥有很多实现类后
- 这时候接口在添加一个抽象方法，每个实现类都需要覆盖重写
- 实现类不需要覆盖重写，但是还想再接口中添加一个抽象方法
- 所以就要用到默认方法–>带有默认方法体
1.6 接口的默认方法使用
- 注：public可以省略不写，default不能
- 注：默认方法会被实现类继承下去
- 注意事项：
- 接口的默认方法，可以通过接口实现类对象，直接调用
- 接口的默认方法，也可以被接口实现类进行覆盖重写
- 注：调用抽象方法，实际运行的是右侧的实现类
- 注：调用默认方法，如果实现类当中没有，会向上找接口
//定义了一个接口：MyInterfaceDefault.java
public interface MyInterfaceDefault {
//抽象方法
public abstract void methodAbs();
//新添加的抽象方法
//public abstract void methodAbs2();
//想新添加方法，改成默认方法
public default void methodDefault(){
System.out.println("这是新添加的默认方法");
}
}
//定义了一个实现类a：MyInterfaceDefaultA.java
public class MyInterfaceDefaultA implements MyInterfaceDefault {
@Override
public void methodAbs() {
System.out.println("实现了抽象方法， AAA");
}
}
//定义了一个实现类b:MyInterfaceDefaultB.java
public class MyInterfaceDefaultB implements MyInterfaceDefault {
@Override
public void methodAbs() {
System.out.println("实现了抽象方法， BBB");
}
//覆盖重写了methodDefault
@Override
public void methodDefault() {
System.out.println("实现类B覆盖重写了接口的默认方法");
}
}
//主方法：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覆盖重写了接口的默认方法
}
1.7 接口的静态方法定义（Java 8）
- 格式：
public static 返回值类型 方法名称(参数列表){ 方法体 }
- 提示：就是将abstract或者default换成static即可，带上方法体。
1.8 接口的静态方法使用
- 注：
- 不能通过接口实现类的对象来调用接口当中的静态方法。
- 正确用法：
- 格式：
接口名称.静态方法名(参数);- 静态方法和对象无关，和类有关，所以直接用接口调用方法
- 直接——>接口名称.方法就行
1.9 接口的私有方法定义和使用（Java 9）
- 问题描述：
- 我们需要抽取一个共有的方法，用来解决两个默认方法之间重复代码的问题
- 但是，这个共有的方法不应该让实现类使用，应该是私有化的。
- 我们需要抽取一个共有的方法，用来解决两个默认方法之间重复代码的问题
- 解决方法：
- 从Java 9 开始，接口当中允许定义私有方法
- ++普通私有方法++，解决多个默认方法之间重复代码问题
- 格式：
private 返回值类型 方法名称(参数){ 方法体 } - ++静态私有方法++，解决多个静态方法之间重复代码问题
- 格式：
private static 返回值类型 方法名称(参数){ 方法体 }
- ++普通私有方法++，解决多个默认方法之间重复代码问题
- 从Java 9 开始，接口当中允许定义私有方法
1.10 接口的常量定义和使用
- 接口当中也可以定义“成员变量”，但是必须使用public static final三个关键字进行修饰
- 从效果上看，这其实就是接口的【常量】
- 格式：
public static final 数据类型 常量名称 = 数据值;
- 备注：一旦使用final关键字进行修饰，说明不可改变
- 注：接口当中的常量，可以省略 public static final（不写也照样是这样）
- 注：接口当中的常量，必须进行赋值，不能不赋值,且赋值完不能改变
- 注：起接口的常量名时候要大写，多个要用_隔开
- int NUM = 10;
- int NUM_OF_CLASS = 20;
1.11 接口的内容小结
1.12 继承父类并实现多个接口
- 使用接口时候的注意事项：
- 接口是没有静态代码块或者构造方法的。
- static {}
- public 接口名称() {}
- 一个类的直接父类是唯一的，但是一个类可以同时实现多个接口
public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB { //覆盖重写所有抽象方法 } - 如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
- 如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。
public abstract class 实现类名 implements 接口名{} - 如果实现类所实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写
- 一个类如果直接父类当中的方法和接口当中的默认方法产生了冲突，优先用父类当中的方法【重点】
- 和接口抽象方法重复没事–>因为++没有方法体++
- 接口是没有静态代码块或者构造方法的。
- 注：Object类是所有类直接或间接的父类(只不过默认省略了)
public class MyInterfaceImpl ++extends Object++ implements MyInterfaceA, MyInterfaceB { //覆盖重写所有抽象方法 } - 注：写代码的角度来看，接口就是用来规范类的方法【重点】
1.13 接口之间的多继承
- 类和接口相关的几种关系
- 类与类之间是单继承的，直接父类只有一个。
- 类与接口之间是多实现的，一个类可以实现多个接口。
- 接口与接口之间是多继承的。
- 注：
- 多个父接口当中的抽象方法如果重复，没关系。（没有方法体【重点】）
- 多个父接口当中的默认方法如果重复，有关系了。
- 那么子接口必须进行默认方法的覆盖重写，而且带着default关键字（不能省略）【重点】
//定义了一个接口：MyInterfaceA.java public interface MyInterfaceA { public abstract void methodA(); public abstract void common(); public default void methodDefault(){ System.out.println("AAA"); } } //定义了一个接口：MyInterfaceB.java public interface MyInterfaceB { public abstract void methodB(); public abstract void common(); public default void methodDefault(){ System.out.println("BBB"); } } //定义了一个接口继承上面两个接口：MyInterface.java public interface MyInterface extends MyInterfaceA, MyInterfaceB { public abstract void method(); @Override default void methodDefault() { } } //定义一个实现类：MyInterfaceImpl public class MyInterfaceImpl implements MyInterface { @Override public void method() { } @Override public void methodA() { } @Override public void methodB() { } @Override public void common() { } } //主方法：Demo01Relations.java public static void main(String[] args) { MyInterfaceImpl myInterface = new MyInterfaceImpl(); myInterface.methodDefault(); }
第二章 多态
2.1 多态的概述
2.2 多态的格式和使用
- 代码当中体现多态性，其实就是一句话：父类引用指向子类对象
- 格式：
- 父类名称 对象名 = new 子类名称();
- 或者：
- 接口名称 对象名 = new 实现类名称();
- 多态：左父右子
2.3 多态中成员变量的使用特点
- 回顾（访问成员变量的两种方式）：
- 直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找
Fu obj = new Zi(); //父类num=10 System.out.println(obj.num); //10：看生成对象的等号左边是谁，优先用谁，没有则向上找- 间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则向上找
- 子类没有覆盖重写，就是父：10
- 子类覆盖重写，就是子：20
- 成员变量不能覆盖重写
定义一个类：Fu.java
public class Fu {
int num = 10;
public void showNum(){
System.out.println(num);
}
}
定义一个子类：Zi.java
public class Zi extends Fu {
int num = 20;
int age = 30; //用于对象左侧是父类，所有调用不到这个
@Override
public void showNum() {
System.out.println(num);
}
}
主方法：Demo01MultiField.java
public static void main(String[] args) {
Fu obj = new Zi();
System.out.println(obj.num); //10：看生成对象的等号左边是谁，优先用谁，没有则向上找
System.out.println("===========");
obj.showNum();
}
- 其中int age = 30; //用于对象左侧是父类，所有调用不到这个
2.4 多态中成员方法的使用特点
- 在多态的代码当中，成员方法的访问规则是：
- 看new的是谁，就优先用谁，没有则向上找
- 口诀：编译看左边，运行看右边(看的是创建对象等号两侧)
- 编译（是一个动作）：就是把.java源代码翻译成.class字节码
//obj.methodZi(); //错，编译时候看左边，左边是Fu，Fu当中没有methodZi方法，所以编译错误
- 对比成员变量和成员方法
- 成员变量：编译看左边，运行还看左边
- 成员方法：编译看左边，运行看右边
//定义一个类：Fu.java
public class Fu {
int num = 10;
public void showNum(){
System.out.println(num);
}
public void method(){
System.out.println("父类方法");
}
public void methodFu(){
System.out.println("父类特有方法");
}
}
//定义一个子类：Zi.java
public class Zi extends Fu {
int num = 20;
int age = 30; //用于对象左侧是父类，所有调用不到这个
@Override
public void showNum() {
System.out.println(num);
}
}
主方法：Demo01MultiMethod.java
public static void main(String[] args) {
Fu obj = new Zi();
obj.method();
obj.methodFu();
//obj.methodZi(); //错，编译时候看左边，左边是Fu，Fu当中没有methodZi方法，所以编译错误
}
2.5 使用多态的好处
- 无论右边new的时候换成那个子类对象，等号左边调用方法都不会变化（更加灵活）
2.6 面向对象的向上转型
- 对象的向上转型，其实就是多态写法：
- 格式：
- 父类名称 对象名 = new 子类名称();//父类引用指向子类对象
- 含义：
- 右侧创建一个子对象，把他当中父类来看待使用
- 类似于：double num = 100; //对的，int–>double(自动类型转换)
- 注：向上转型一定是安全的【重点】
- 注：向上转型是从小范围到大范围
//定义一个父类：Animal.java
public abstract class Animal {
public abstract void eat();
}
//定义一个子类：Cat.java
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
//主方法：Demo01Main.java
public static void main(String[] args) {
//父类引用指向子类对象
Animal animal = new Cat();
animal.eat();
}
2.7 面向对象的向下转型
- 向上转型的弊端：
- 对象一旦向上转型为父类，那么就无法调用子类原本特有的内容
- 解决方案：
- 用对象的向下转型【还原】
- 格式：
- 子类名称 对象名 = （子类名称）父类对象名;
Animal animal = new Cat(); Cat cat = (Cat)animal; - 含义：
- 将父类对象，【还原】成为本来的子类对象。（类似于：强制类型转换–>int num = (int)10.0;可以， int num = (int)10.5;不可以，精度损失）
- 注意事项：
- 必须保证对象本来创建的时候，就是猫，才能向下转型为猫
- 如果对象创建的时候本来不是猫，现在非要向下转型为猫
- 不报错，但是会运行异常
- java.lang.ClassCastException：类转换异常
//定义一个父类：Animal.java
public abstract class Animal {
public abstract void eat();
}
//定义一个子类：Cat.java
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
public void catchMouse(){
System.out.println("猫抓老鼠");
}
}
//定义另一个子类：Dog.java
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗吃屎");
}
public void watchHouse(){
System.out.println("狗看家");
}
}
//主方法：Demo01Main.java
public static void main(String[] args) {
//父类引用指向子类对象
Animal animal = new Cat();
animal.eat();
//animal.catchMouse(); //错，父类没有该方法
//向下转型
Cat cat = (Cat)animal;
cat.catchMouse();
//向下错误转型，因为new的是一只猫
//Dog dog = (Dog)animal; //错误写法，不报错，但是会运行异常
//dog.watchHouse();
int num = (int)10.5; //不行，精度损失
System.out.println(num);
}
2.8 用instanceof关键字进行类型转换
- 如何才能知道一个父类的引用的对象，本来是什么子类
- 格式：
- 对象 instanceof 类名称
- 这将会得到一个boolean值结果，也就是判断前面的对象能不能当做后面类名称的实例
- 向下转型时候怕转错了一定要用instanceof来进行判断
//定义一个父类：Animal.java
public abstract class Animal {
public abstract void eat();
}
//定义一个子类：Cat.java
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
public void catchMouse(){
System.out.println("猫抓老鼠");
}
}
//定义一个子类：Dog.java
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗吃屎");
}
public void watchHouse(){
System.out.println("狗看家");
}
}
//主方法：Demo02Instanceof
public class Demo02Instanceof {
public static void main(String[] args) {
Animal animal = new Cat();
animal.eat();
giveMeAnAnimal(new Dog());
}
public static void giveMeAnAnimal(Animal animal){
//如果希望调用子类特有的方法，需要向下转型
//判断一下父类引用animal本来是不是Dog
if(animal instanceof Dog){
Dog dog = (Dog) animal;
dog.watchHouse();
}
//判断一下animal本来是不是Cat
if(animal instanceof Cat){
Cat cat = (Cat) animal;
cat.catchMouse();
}
}
}
- 结果：
- 猫吃鱼
- 狗看家
2.9 笔记本USB接口案例_分析
2.9 笔记本USB接口案例_实现
//定义一个接口USB.java
public interface USB {
//因为不知道打开的是什么设备所以用abstract
public abstract void open(); //打开设备
public abstract void close(); //关闭设备
}
//定义一个笔记本类：Computer.java
public class Computer {
public void powerOn(){
System.out.println("笔记本电脑开机");
}
public void powerOff(){
System.out.println("笔记本电脑关机");
}
//使用USB设备的方法，使用接口作为方法的参数
public void userDevice(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(); //关闭设备
}
}
//定义一个鼠标实现类：Mouse.java
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("鼠标点击");
}
}
//定义一个键盘实现类：Keyboard.java
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("键盘输入");
}
}
//主方法：DemoMain.java
public static void main(String[] args) {
Computer computer = new Computer();
computer.powerOn();
//准备一个鼠标供电脑使用(首先向上转型)
USB usbMouse = new Mouse(); //多态写法（第一种）
computer.userDevice(usbMouse);
//准备一个键盘
Keyboard usbKeyboard = new Keyboard(); //没有使用多态（第二种）
//参数是一个USB类型，传递进去的是实现类对象
computer.userDevice(usbKeyboard); //也发生了向上转型
//使用子类对象，匿名对象，也可以（第三种）
//computer.userDevice(new Keyboard()); //也可以
computer.powerOff();
}
内容总结
以上是互联网集市为您收集整理的Java语言入门||02_面向对象与常用类||day10_接口，多态全部内容，希望文章能够帮你解决Java语言入门||02_面向对象与常用类||day10_接口，多态所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。
来源：【匿名】