如何在eclipse中看哪个类继承某个接口

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了如何在eclipse中看哪个类继承某个接口相关的知识，希望对你有一定的参考价值。

如何在eclipse中看哪个类继承某个接口，有什么快捷键吗？

1，光标置于类名，按F4可以查询出它的父类，以及实现子类。
2，光标移到这个接口类名上，Ctrl+T 就可以看到了。
3，如果你想从接口方法直接定义到实现类的方法，同样将光标放在接口方法上Ctrl+T，就可以实现。 参考技术A 点这个接口的名字 然后ctrl+alt+g就可以找到了本回答被提问者采纳 参考技术B 鼠标移类名上去,按F3. 可以看到上级定义, 一级级上去,可以找到源头.

如果你设置了java的源码包,鼠标移上去的时候,应该会有窗口浮动出来,在哪里可以看到它的定义, 当然这只限于jdk里的类,自定义的类,就需要你在写源代码时,加上标准的doc类说明. 再有子类时,鼠标移上去就可以看到了. 参考技术C 按住Ctrl键点击那个类。

Java语法包 继承 多态 抽象类 接口

目录

一、包

二、继承

继承

protected 关键字

四种访问权限

final关键字

三、多态

向上转型

动态绑定

方法重写

重载和重写的区别

super 关键字

super与this的区别

四、抽象类

抽象类

接口

接口与抽象类区别

一、包

包 (package) 是组织类的一种方式. 使用包的主要目的是保证类的唯一性

将类将放到包中

基本规则

在文件的最上方加上一个 package 语句指定该代码在哪个包中.

如果一个类没有 package 语句, 则该类被放到一个默认包中

包的访问权限控制

如果某个成员不包含 public 和 private 关键字, 此时这个成员可以在包内部的其他类使用, 但是不能在包外部的类使用.

二、继承

继承

对共性的抽取，使用extends关键字进行处理，可以对代码重复使用

语法规则

继承对象叫做子类、派生类

被继承对象叫做父类、基类、超类

基本语法

class 子类 extends 父类

1，Java当中的继承是单继承，不能同时继承两个以上的类，包括两个

2，子类构造的同时，要先帮父类进行构造，子类帮助构造，使用构造方法

3，对于父类的 private 的字段和方法, 子类中是无法访问的

4，子类的实例中, 也包含着父类的实例. 可以使用 super 关键字得到父类实例的引用

5，如果一个类不想被继承，可以使用final修饰

class Animal 
    public String name = "hello";
    public int age;
    protected int count;

    public Animal(String name,int age) 
        this.name = name;
        this.age = age;
    

    public void eat() 
        System.out.println(name+"eat()");
        System.out.println(count);
    


class Dog extends Animal

    public Dog(String name,int age) 
        super(name,age);
    


class Bird extends Animal
    public String wing;
    public String name;//null

    public Bird(String name,int age,String wing) 
        super(name,age);
        this.wing = wing;
    

    public void fly() 
        System.out.println(super.name+"fly()"+age);
    

public class Text1 

    public static void main(String[] args) 
        Dog dog = new Dog("haha",19);
        System.out.println(dog.name);
        System.out.println(dog.age);
        dog.eat();

 super关键字

不能出现在静态的方法中，父类对象的引用

1，super()调用父类的构造方法

2，super.func()

3，super.data

protected 关键字

刚才我们发现, 如果把字段设为 private, 子类不能访问. 但是设成 public, 又违背了我们 "封装" 的初衷. 两全其美的办法就是 protected关键字

1，对于类的调用者来说, protected 修饰的字段和方法是不能访问的

2，对于类的子类和同一个包的其他类 来说, protected 修饰的字段和方法是可以访问的

四种访问权限

NO范围privatedefaultprotectedpublic
1同一包中的同一类√√√√
2同一包中的不同类√√√
3不同包中的子类√√
4不同包中的非子类√

final关键字

1，修饰一个变量或者字段的时候, 表示 常量 (不能修改).

2，final 关键字也能修饰类, 此时表示被修饰的类就不能被继承

三、多态

向上转型

1，直接赋值

2，函数的参数

3，方法返回

class Animal 
    public String name = "hello";
    public int age;
    protected int count;

    public Animal(String name,int age) 
        eat();
        this.name = name;
        this.age = age;
    

    public  void eat() 
        System.out.println(name+" ani::eat()");
    


class Dog extends Animal 

    public Dog(String name,int age) 
        super(name,age);
    


public class Text1 

    public static void main(String[] args) 
        Animal animal = new Dog("花花",19);//父类引用子类对象

动态绑定

1，父类引用子类对象

2，通过这个父类引用调用父类和子类同名的覆盖方法

class Animal 
    public String name;
    public int age;
    protected int count;

    public Animal(String name,int age) 
        this.name = name;
        this.age = age;
    

    public  void eat() 
        System.out.println(name+" ani::eat()");
    


class Dog extends Animal 

    public Dog(String name,int age) 
        super(name,age);
    

    @Override
    public  void eat() 
        System.out.println(name+" 狼吞虎咽的eat()");
    


public static void main(String[] args) 
        //通过父类引用只能访问父自己的成员
        Animal animal1 = new Dog("花花",3);
        animal1.eat();
        Animal animal2 = new Bird("蛋蛋",4,"飞翔");
        animal2.eat();
        System.out.println(animal2.name);

方法重写

1，方法名相同

2，参数列表相同（个数+参数类型）

3，返回值相同

4，方法不可以是static

5，子类的访问修饰限定，要大于等于父类

6，private方法不能够重写，被final修饰的方法不能被重写

class Animal 
    public String name = "hello";
    public int age;
    protected int count;

    public Animal(String name,int age) 
        eat();
        this.name = name;
        this.age = age;
    

    public  void eat() 
        System.out.println(name+" ani::eat()");
    


class Dog extends Animal
    public Dog(String name,int age) 
        super(name,age);
    

    @Override
    public void eat() 
        super.eat();
    


class Bird extends Animal
    public Bird(String name, int age) 
        super(name, age);
    

    @Override
    public void eat() 
        super.eat();

重载和重写的区别

NO区别重载重写
1概念方法名相同，参数的个数和类型相同方法名名称，返回值类型，参数的类型及个数完全相同
2范围一个类继承关系
3限制没有权限要求被覆写的方法不能拥有比父类更严格的访问权限

super 关键字

不能出现在静态的方法中，父类对象的引用

1，super()调用父类的构造方法

2，super.func()

3，super.data

class Animal 
    public String name = "hello";
    public int age;
    protected int count;

    public Animal(String name,int age) 
        eat();
        this.name = name;
        this.age = age;
    

    public  void eat() 
        System.out.println(name+" ani::eat()");
    


class Dog extends Animal
    public Dog(String name,int age) 
        super(name,age);
        super.eat();
    

    @Override
    public void eat() 
        super.eat();

super与this的区别

NO区别thissuper
1概念访问本类中的属性和方法由子类访问父类中的属性、方法
2查找范围先查找本类，如果本类没有就调用父类不查找本类而直接调用
3特殊表示当前对象无

四、抽象类

抽象类

1，包含抽象方法的类，叫做抽象类

2，抽象方法，一个没有具体的实现的方法，被abstract修饰

3，抽象类不能被实例化，所以只能被继承

4，抽象类中可以包含和普通类一样的成员和方法

5，一个普通类，继承一个抽象类，这个普通类需要重写这个抽象类的所有抽象方法

6，抽象类最大作用就是为了被继承

7，一个抽象类A继承抽象类B，A可以不实现抽象父类B的抽象方法

8，抽象类不能被final修饰，抽象方法也不能被final修饰

9，针对7，普通类继承A，那么必须重写A和B的抽象方法

abstract class Shape 

    public void func() 
        System.out.println("测试普通方法！");
    
    public abstract void draw();//抽象方法

abstract class A extends Shape
   

class V extends Shape
    @Override
    public void func() 
        super.func();
    

    @Override
    public void draw() 
        
    


abstract class Shape 

    public void func() 
        System.out.println("测试普通方法！");
    
    public abstract void draw();//抽象方法

abstract class A extends Shape

    public void count()
        System.out.println("sdspjd");
    

class V extends Shape
    @Override
    public void func() 
        super.func();
    
    @Override
    public void draw() 
    


class B extends A
    @Override
    public void func() 
        super.func();
    
    @Override
    public void draw()

接口

1，使用interface来修饰

2，接口当中的普通方法，不能有具体的实现。非要实现通过关键字default来修饰

3，接口中可以有静态方法，里面所有的方法都是public

4，抽象方法，默认是public abstract的

5，接口不可以通过关键字new来实例化

6，类和接口之间的关系通过implenebts实现

7，当一个类实现了一个接口，必须要重写接口中的抽象方法

8，接口成员变量默认是public static final修饰的

9，当一个类实现一个接口，重写这个方法的时候，必须加上public

10，一个类可以通过关键字extends继承一个抽象类或者普通类，但是只能继承一个类。同时，也可以通过implements实现多个接口，接口之间用逗号隔开

interface IShape 
    void draw();//抽象方法


class Rect implements IShape 

    @Override
    public void draw() 
        System.out.println("♦");
    

    /*@Override
    public void func() 
        System.out.println("重写接口当中的默认方法");
    */


class Flower implements IShape 
    @Override
    public void draw() 
        System.out.println("❀");
    


class Triangle implements IShape 
    @Override
    public void draw() 
        System.out.println("△");
    

class Cycle implements IShape 
    @Override
    public void draw() 
        System.out.println("●");
    

interface  IA 
    int A = 10;
    void funcA();//public abstract

interface IB 
    void funcB();

abstract class BClass 



class AClass extends BClass implements IA,IB 
    public void funcA() 
        System.out.println("A::funcA()");
        System.out.println(A);
    

    @Override
    public void funcB() 
        System.out.println("A::funcB()");

接口与抽象类区别

NO区别抽象类接口
1结构组成普通类+抽象方法抽象方法+全局变量
2权限各种权限public
3子类的使用extendsimplements
4关系一个抽象类可以实现若干个接口接口不能继承抽象类，但是接口可以使用extends关键字继承多个父类接口
5子类限制一个子类只能继承一个抽象类一个子类可以实现多个接口

以上是关于如何在eclipse中看哪个类继承某个接口的主要内容，如果未能解决你的问题，请参考以下文章

如何在eclipse中查看一个类中的所有方法和域

eclipse 如何查找类

eclipse如何快速查找某个类

eclipse如何快速查找某个类

关于eclipse中java项目管理中如何查找哪个类文件包含main

从具有相同方法名称的多个接口继承