Java接口与多态

于 2024-07-24 15:50:14 发布
阅读量581 收藏 6
点赞数 6
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_70718945/article/details/140663745
版权

一、接口

接口：是一个引用数据类型，是一种规则，标准

关键字：

  Interface 接口

 Public  interface 接口名（）{}

Implements 实现

实现类 implements 接口名{}

接口中可以定义的成员：jdk7以及以前：抽象方法：public abstracr->即使不写默认也有

定义接口：public interface 接口名{}

实现：public class  实现类类名 implements 接口名{}

使用：

实现类实现接口

重写接口中的抽象方法

创建实现类对象（接口不能直接new对象）

调用重写方法

public interface USB {
    public abstract void open();
    public abstract void close();

}
public class Mouse implements USB {
    @Override
    public void open() {
        System.out.println("鼠标打开");
    }

    @Override
    public void close() {

        System.out.println("鼠标关闭");
    }
}

public class Test01 {
    public static void main(String[] args) {
        Mouse mouse = new Mouse();
        mouse.open();
        mouse.close();
    }
}

1.抽象方法

定义格式：

   Public  abstract  返回值类型  方法名（形参）;

注意：不写public  abstract默认也有

使用：定义实现类，实现接口

重写抽象方法

创建实现类对象，调用重写的方法

public interface USB {
    public  abstract void open();
    String close();
}
public class Mouse implements USB {
    @Override
    public void open() {
        System.out.println("鼠标打开");
    }

    @Override
    public String close() {
        return "鼠标关闭";
    }
}

public class Test01 {
    public static void main(String[] args) {
        Mouse mouse = new Mouse();
        mouse.open();
        String close = mouse.close();
        System.out.println(close);
    }
}

2.默认方法

格式：public  default  返回值类型  方法名（形参）{

           方法体

            Return 结果

}

使用：定义实现类，实现接口

       默认方法可重写，可不重写

       创建实现类对象，调用默认方法

3.静态方法

定义格式：public  static  返回值类型  方法名（形参）{

 方法体

            Return 结果

}

使用：接口名直接调用

默认方法和静态方法->可以作为临时加的小功能来使用

public interface USB {
    //默认方法
    public  default void methodDef(){
        System.out.println("我是默认方法");
    }



    //静态方法
    public static void methodSta(){
        System.out.println("我是接口中的静态方法");
    }
}
public class Mouse implements USB {
    @Override
    public   void methodDef(){
        System.out.println("我是重写接口的默认方法");
    }



}
public class Test01 {
    public static void main(String[] args) {
        Mouse mouse = new Mouse();
       mouse.methodDef();


        System.out.println("=======");

        USB.methodSta();

    }

}

4.成员变量

格式：public static  final  数据类型  变量名=值

相关知识点：final   代表最终的，被他修饰的变量，不能二次赋值可以视为常量

特点：不写public  static  final  默认也有

使用：接口名直接调用

注意：被static  final修饰的成员变量需要手动赋值

     习惯上我们将static  final修饰的成员变量名大写

public interface USB {
    public static final int NUM1=100;
    int NUM2=200;//不屑public static final  默认也有
}

public class Test01 {
    public static void main(String[] args) {
        System.out.println(USB.NUM1);
        System.out.println(USB.NUM2);
    }
    
}

5.接口的特点

接口可以多继承->一个接口可以继承多个接口

   Public   interface   InterfaceA extends  InterfaceB，InterfaceC{}

接口可以多实现->一个实现类可以实现一个或者多个接口

  Public class InterfaceImpl  implements  InterfaceA，InterfaceB{}

一个子类可以继承一个父类的同时实现一个或者多个接口

  Public  class  Zi  extends  Fu  implements   InterfaceA，InterfaceB{}

注意：

继承也好，实现接口也罢，只要是父类中或者接口的抽象方法，子类或者实现类都要重写

当一个类实现多个接口时，如果接口中的抽象方法有重名且参数一样的，只需要重写一次

当一个类实现多个接口时，如果多个接口默认方法中有重名且参数一样的，必须需要重写一次默认方法

public interface InterfaceA {
    public abstract void method();

    public default void methodDef(){
        System.out.println("我是接口A中的默认方法");
    }
}

public interface InterfaceB {
    public abstract void method();
    public default void methodDef(){
        System.out.println("我是接口A中的默认方法");
    }
}
public class InterfaceImpl  implements InterfaceA,InterfaceB {
    @Override
    public void method() {
        System.out.println("重写的method方法");
    }

    @Override
    public void methodDef() {
        System.out.println("重写后的默认方法");
    }
}

6.接口和抽象类的区别

相同点：都位于继承体系的顶端，用于被其他类实现或者继承

都不能new

都包含抽象方法，其子类或者实现类都必须重写这些抽象方法

不同点：

抽象类：一般作为父类使用，可以有成员变量，构造，成员方法，抽象方法等

接口：成员单一，一般抽取接口，抽取的都是方法，视为功能的大集合

类不能多继承，但是接口可以

二、多态

面向对象三大特征：封装  继承  多态

怎么学：不要从字面意思上理解多态这两个字要从使用形式上掌握

要知道多态的好处

要知道多态的前提

前提：

必须要有子类继承或者接口实现关系

     必须要有方法的重写（没有重写，多态无意义）多态主要在于这个重写方法

     New对象：父类引用指向子类对象

       Fu fu=new  zi（） ->理解为大类型接受了一个小类型的数据->比如  double b=10

注意：多态下不能直接调用子类特有的功能

1.多态的基本使用

public abstract class Animal {
    public abstract void eat();
}
public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void catchMouse(){
        System.out.println("猫捉老鼠");
    }
}
public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("啃骨头");
    }

    //特有方法
    public void lookDoor(){
        System.out.println("狗会看门");
    }
}
public class Test01 {
    public static void main(String[] args) {
        //原始
        Dog dog = new Dog();
        dog.eat();
        dog.lookDoor();

        Cat cat = new Cat();
         cat.eat();
         cat.catchMouse();


        System.out.println("=========");

        //多态性形式new对象
        Animal animal=new Dog();//相当于double b=10
        animal.eat();//重写，animal接受的时dog对象所以调用的时dog中的eat
        //animal.lookDoor(); 多态前提下不能直接调用子类特有成员

    }
}

2.多态条件下的成员访问特点

（1）成员变量

看等号左边是谁，先调用谁中的成员变量

（2）成员方法

看new的是谁先调用谁中的成员方法，子类没有，找父类

public class Fu {
    int num=1000;

    public  void method(){
        System.out.println("我是父类中的method方法");
    }

}

public class Zi  extends Fu{
    int num=100;
    public  void method(){
        System.out.println("我是子类中的method方法");
    }

}
public class Test01 {
    public static void main(String[] args) {
        Fu fu=new Zi();
        System.out.println(fu.num);

        fu.method();//子类中重写的method方法
    }
}

3.多态的好处

概述：如果使用原始方式new对象（等号左右两边一样），既能调用重写的，还能调用继承的，还能调用自己特有的成员，但是多态方式new对象，只能调用重写的，不能直接调用子类特有的成员，为什么还用多态呢？

多态方式和原始方式new对象的优缺点：

原始方式：

   优点：既能调用重写的，还能调用父类非私有的，还能调用自己特有的

缺点：扩展性差（调方法，传对象，还得单独创建一个方法）

多态方式：

   优点：扩展性强

   缺点：不能直接调用子类特有的功能

Fu fu=new Zi（）

public abstract class Animal {
    public abstract void eat();
}

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }


    //特有方法
    public void catchMouse(){
        System.out.println("猫捉老鼠");
    }
}
public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("啃骨头");
    }

    //特有方法
    public void lookDoor(){
        System.out.println("狗会看门");
    }
}
public class Test01 {
    public static void main(String[] args) {

        Dog dog=new Dog();
        dog.eat();//重写的
        dog.lookDoor();//特有的
         //dog=new Cat();   不可以扩展性差
        System.out.println("=============");
        method(dog);

        Cat cat = new Cat();
        method1(cat);



    }


    public static void method(Dog dog){
        dog.eat();
        dog.lookDoor();
    }


    public static void method1(Cat cat){
        cat.eat();
        cat.catchMouse();
    }

}

public class Test02 {
    public static void main(String[] args) {

        /*
        *
        * double  b=10;
        * b=100L;
        *
        * */


        Animal animal=new Dog();
        animal.eat();

        animal=new Cat();
        animal.eat();
        System.out.println("========");

        Dog dog=new Dog();
        method(dog);

        Cat cat = new Cat();
        method(cat);

        /*
        *
        * 形参传递父类类型，调用此方法父类类型可以接收任意他的子类对象
        * 传递哪个子类对象，就指向哪个子类对象，就调用哪个子类对象重写的方法
        *
        * */

    }

    public static void method(Animal animal){//Animal animal=dog
        animal.eat();
    }

}

形参传递父类类型，调用此方法父类类型可以接收任意他的子类对象
传递哪个子类对象，就指向哪个子类对象，就调用哪个子类对象重写的方法

4.多态中的转型

向上转型

父类引用指向子类对象  比如double b=1；

向下转型

好比强转，将大类型强制转成小类型

表现方式：

父类类型  对象名1=new 子类对象（）->向上转型   double  b=1；

子类类型   对象名2=（子类类型）对象名1->向下转型   int i=(int)b

想要调用子类特有功能，我们就需要向下转型

转型中可能出现的问题（类型转换异常）

如果等号左右两边出现类型不一致，会出现类型转换异常（ClassCastException）

解决：

   在向下转型之前，先判断类型

怎么判断类型instanceof

  判断结果时boolean型

使用：

  对象名  instanceof  类型->判断的是关键字前面的对象是否符合关键字后面的类型

public abstract class Animal {
    public abstract void eat();
}
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }


    //特有方法
    public void catchMouse(){
        System.out.println("猫捉老鼠");
    }
}

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("啃骨头");
    }

    //特有方法
    public void lookDoor(){
        System.out.println("狗会看门");
    }
}

public class Test01 {
    public static void main(String[] args) {
        //多态new对象
        Animal animal=new Dog();
        animal.eat();
      // animal.lookDoor();  多态不能调用子类特有功能

        //向下转型
        Dog dog=(Dog) animal;
        dog.eat();
        dog.lookDoor();


    }
}

public class Test01 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        method(dog);

        System.out.println("======");
        Cat cat = new Cat();
        method(cat);


    }

    private static void method(Animal animal) {
        animal.eat();


        /*
        * 这里会出现类型转换异常（ClassCastException）
        * 原因：当调用method，传递cat对象时，animal代表的就是cat对象
        * 此时我们将代表cat对象的animal强转成dog
        * 此时等号左右两边类型不一致了，所以出现了类型转换异常
        *
        *
        *
        * */

       /* Dog dog=(Dog) animal;
        dog.lookDoor();*/




       if (animal instanceof Dog){
           Dog dog=(Dog) animal;
           dog.eat();
           dog.lookDoor();
       }

       if (animal instanceof Cat){
           Cat cat=(Cat) animal;
           cat.eat();
           cat.catchMouse();
       }
    }
}

三、权限修饰符

在Java中提供四种访问权限，使用不同的访问权限修饰符时，被修饰的内容会有不同的访问权限

Public：公共的，最高权限的，被public修饰的成员，在哪里都能访问

Protected：受保护的

Default：默认的，注意，不写权限修饰符就是默认权限，不能直接把default写出来

Private：私有的，只能在自己的类中直接访问

publicprotecteddefaultprivate
同类yesyesyesyes
同包不同类yesyesyesno
不同包子父类yesyesnono
不同包非子父类yesnonono

属性：用private->封装思想

成员方法public->便于调用

构造public->便于new对象

如有不足，请多多指教，谢谢

编程里的小白
关注
  • 6
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值