java抽象类与接口 中 相同方法的调用

Posted 2023-05-16

抽象类和接口中有同一个抽象方法,一个类继承了那个抽象类并实现了那个接口,那么这个子类应该怎么写?

参考技术A interface MyInterface
public void m();


abstract class MyClass
public void m()
System.err.println("asdfasdfasdf");




public class InterfaceClassInherit extends MyClass implements MyInterface

public static void main(String[] args)
MyInterface obj = new InterfaceClassInherit();
obj.m();



在上面的程序中,接口MyInterface和抽象类MyClass中均有一个名为m()的无返回类型的函数.当某类继承MyClass类和实现MyInterface接口时,类中的m()方法覆盖了继承自接口的m()方法,相当于重写了这个方法.

用接口MyInterface声明一个指向自创类对象的引用.该引用在调用m()方法时调用的是自创类继承自MyClass的m()

改程序的结果是打印出字符串"asdfasdfasdf" 参考技术B 必然调用的是该类中自己的方法.
因为首先实现接口必然重写接口中的方法.
重写后因为同名,所以覆盖了抽象类中的方法.
因此调用的是该类自己重写的方法..
如下例.
//抽象类
abstract
class
AbstractClass

public
void
work()

System.err.println("AbstractClass");


//
接口
interface
SomeInterface

public
void
work();

//
子类
class
CommonClass
extends
AbstractClass
implements
SomeInterface

public
void
work()

System.err.println("CommonClass");


//
测试类
public
class
SameMethodTest

public
static
void
main(String[]
args)

//
TODO
Auto-generated
method
stub
CommonClass
cc
=
new
CommonClass();
cc.work();

参考技术C abstract class mm

public abstract void play();

interface tt

void play();

public class Inte extends mm implements tt


public static void main(String args[])

new Inte().play();

public void play()

System.out.println("我正在玩^^^^^^^^");



希望对你有所帮助本回答被提问者采纳 参考技术D 我印象中 是只写一个就行了，他同时实现了抽象类和接口的那个方法。
我再验证一下去。
我试过了，就是这样。

java -- 抽象类与接口类

一.protected权限修饰符

public class ProtectedTest 
    public static void main(String[] args) 
        
        // protected修饰的属性和方法本包中可以调用。
        // 不同包中的子类也可以访问protected修饰的属性和方法
        Person person = new Person();
    

import com.atguigu.exer.Person;

public class ProtectedTest 
    public static void main(String[] args) 
        Person person = new Person();
        Student stu = new Student();
        stu.demo();
    


// 不同包的子类也可以访问protected修饰的属性和方法
class Student extends Person
    public void demo() 
        System.out.println(protectedName);
        say();
    

public class Person 
    protected String protectedName;
    
    protected void say() 
        System.out.println("say");
    

二.abstract抽象类

1.关键字：abstract（面向对象的四大特性：封装性，继承性，多态性，抽象类）

2.abstract可以修饰方法：抽象方法
　　抽象方法没有方法体

3.abstract可以修饰类：抽象类
　　1.抽象方法所在的类必须为抽象类
　　2.抽象类不能被实例化
　　思考：那么抽象类有构造器吗？有-因为子类的实例化过程：必须调用父类的构造器
　　3.抽象类中可以没有抽象方法。可以有非抽象方法
　　4.非抽象子类必须重写抽象父类中的抽象方法。如果非抽象方法的父类重写了抽象方法，那么子类就不用在重写抽象方法

4.abstract不可以和那些关键字一起使用？
　　private，final，static

public class AbstractTest 
    public static void main(String[] args) 
        Book book = new Book();
        book.read();
    


// 创建一个抽象类
abstract class Library
    // 方法本身就没有实际含义，但是又必须的写因为考虑到多态，所以这样的方法可以声明成抽象方法
     public abstract void read();


class Book extends Library
    public void read() 
        System.out.println("读一本好书，品味一个完整的人生");
    

 

三.类的成员之一：代码块

格式：

说明：
　　1.代码块只能被static修饰

代码块的分类：静态代码块 VS 非静态代码块

静态代码块：
　　1.用来对类中的信息进行初始化
　　2.静态代码块是随着类的加载而加载的，只加载一次
　　3.静态代码块可以有多个，执行顺序从上到下依次执行
　　4.静态代码块中只能 调用类变量和静态方法（因为加载时机不同）
　　5.静态代码块的加载优先于非静态代码块

非静态代码块：
　　1.用来对对象进行初始化
　　2.非静态代码块是随着对象的创建而加载的
　　3.非静态代码的加载优先于构造器
　　4.非静态代码块可以有多个，执行顺序从上到下依次执行
　　 5.非静态代码块中可以调用类变量和静态方法

如果一些是代码只是加载一次，可以考虑放到静态代码块当中

    
        //    非静态代码块
        System.out.println(""+ Name );
        
    
    
    static 
        //静态代码块
        System.out.println("1" + age);
    

四.final关键字

请简述final关键字？
 final修饰的类：不能被继承

final修饰的方法：不能被重写

final修饰的变量：只能被赋值一次，且必须进行初始化（往往修饰的变量作为常量）
final 的赋值方式有三种：显示赋值，代码块赋值，构造器赋值

 *    变量的赋值：1.默认值    2.显示赋值    3.代码块赋值    4.构造器赋值    5.对象名.方法名/对象名.属性
 *
 *    赋值顺序：1 <- 2/3(谁在上，谁先赋值) <- 4 <- 5

例子1

// 设计模板 

public class TemplateMethod 
    public static void main(String[] args) 
        Code code = new Code2();
        code.runTime();
    


abstract class Code
    
    public void runTime()
        // 计算代码开始的时间
        long start = System.currentTimeMillis();
        
        // 执行需要执行的代码
        runCode();
        
        // 计算代码结束时间
        long end = System.currentTimeMillis();
        
        // 计算时间差
        System.out.println("time=" + (end - start));
    
    
    public abstract void runCode();


class Code2 extends Code
    
    public void runCode() 
        for(int i = 1;i < 100;i++)
            if(i % 2 == 0) 
                System.out.println(i);
            
        
    

五.接口类interface

接口在jdk1.8时的新特性：

　　1.接口除了可以有常量和抽象方法，还可以有默认方法和静态方法

　　2.如何调用静态方法：接口名.静态方法名
　　如何调用默认方法：实现类的对象.默认方法名

　　3.类优先原则：一个类的父类和接口中有相同的方法。通过该类的对象调用的该方法是父类中的方法

　　4.一个类中实现了多个接口，如果多个类中有相同的默认方法，那么该类必须重写该方法

　　5.在类中的方法，调用接口中的默认方法：接口名.super.默认方法名

 

接口：interface

格式：interface 接口名

说明：
　　1.接口和类是并列关系
　　2.接口不能被实例化
　　3.接口中只能有常量和抽象方法（jdk1.8之前）
　　4.接口和接口之间的关系：继承关系，而且是多继承
　　5.类和接口的关系：class 类名 implements 接口，而且可以实现多个接口（Java是单继承多实现）
　　6.接口和类之间的多态性

接口类的用法：
　　1.通过接口类可以实现不相关类的相同行为，而不需要考虑这些类之间的层次关系
　　2.通过接口可以指明多个类需要实现的方法，一般用于定义对象的扩张功能
　　3.接口主要用来定义规范。接触耦合关系

public class InterfaceTest 
    public static void main(String[] args) 
        
        Mouse mouse = new Mouse();
        
        Computer computer = new Computer();
        computer.useMouseBlue(mouse);
        computer.useMouseUsb(mouse);
        
        // 创建接口的匿名实现类的对象
        USB kb = new USB() 
            @Override
            public void start() 
                // TODO Auto-generated method stub
                System.out.println("键盘正常连接");
            
            
            @Override
            public void end() 
                // TODO Auto-generated method stub
                System.out.println("键盘断开连接");
            
        ;
        
        computer.useMouseUsb(kb);
        
        
        // 创建了一个匿名实现类的匿名的对象
        computer.useMouseUsb(new USB() 
            
            @Override
            public void start() 
                // TODO Auto-generated method stub
                System.out.println("晚上好");
            
            
            @Override
            public void end() 
                // TODO Auto-generated method stub
                System.out.println("明天见");
            
            
        );
        
    


class Computer
    
    public void useMouseUsb(USB usb) 
        usb.start();
        System.out.println("连接正常");
        usb.end();
    
    
    public void useMouseBlue(BlueTooth bt) 
        bt.startBlue();
        System.out.println("蓝牙连接正常");
        bt.endBlue();
    


interface BlueTooth
    void startBlue();
    void endBlue();


interface USB
    void start(); // 默认会自动添加 public abstract
    void end();


class Mouse implements USB,BlueTooth
    
    @Override
    public void start() 
        System.out.println("鼠标开始运行了");
    
    
    @Override
    public void end() 
        System.out.println("鼠标停止运行了");
    
    
    @Override
    public void startBlue() 
        System.out.println("蓝牙开始连接了");
    
    
    @Override
    public void endBlue() 
        System.out.println("蓝牙断开连接了");