关键词：抽象扩展，接口实现

Java 抽象关键字

abstract关键字用于在Java中实现抽象。它是一个非访问修饰符，用于创建抽象类和方法。

抽象类的作用是包含抽象方法。但是，它也可能包含非抽象方法。使用abstract关键字声明并且没有任何实现的方法称为抽象方法。

语法：-

    abstract class Employee  
    {  
    abstract void work();  
    }   

注意 - 我们不能在非抽象类中声明抽象方法。

抽象关键字规则
不该做的事情

抽象关键字不能与变量和构造函数一起使用。
如果类是抽象类，则无法实例化。
如果一个方法是抽象的，它不包含主体。
我们不能将abstract关键字与final一起使用。
我们不能将抽象方法声明为私有。
我们不能将抽象方法声明为静态。
抽象方法无法同步。

要做的（待定）

抽象关键字只能与类和方法一起使用。
抽象类可以包含构造函数和静态方法。
如果一个类扩展了抽象类，它还必须至少实现一个抽象方法。
抽象类可以包含 main 方法和 Final 方法。
抽象类可以包含重载的抽象方法。
我们可以将局部内部类声明为抽象类。
我们可以用 throw 子句声明抽象方法。

什么是抽象类：

抽象类是被声明为抽象的类——它可能包含也可能不包含抽象方法。抽象类不能实例化，但可以子类化。

什么是抽象方法：

抽象方法是在没有实现的情况下声明的方法（不带大括号，后跟分号），如下所示：
抽象无效 moveTo(double deltaX, double deltaY);

*抽象：*

它的主要目标是通过向用户隐藏不必要的细节来处理复杂性。

仅显示必要的数据并对用户隐藏不需要的详细信息。

对于抽象类，我们有子类。 这个子类也可以是抽象类吗？
是的，这样的话，Child类就不能被实例化了。

参考：https://www.javatpoint.com/abstract-keyword-in-java

package chennai.velachery;

public abstract class Parent {

    abstract void getJob();

    void studyWell()
    {
        System.out.println("Focus On Maths, Science"); 
    }
    static void display()
    {
        System.out.println("Hi");
    }
    public static void main(String[] args) {
        Parent.display();
//      Parent pp = new Parent(); 
//      pp.display();
//      pp.studyWell(); 
//      pp.getJob();

    }



}

package chennai.velachery;

public class Child extends Parent {


    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Child ch = new Child(); 
        ch.getJob();
        ch.studyWell();
        Child.display();
    }

    @Override //Annotation : Metadata
    //Data about data
    void getJob() {
        // TODO Auto-generated method stub

    }


}

示例2：

package chennai.velachery;

public abstract class Parent1 {

    public void watch_tv()
    {
        System.out.println("Watching TV");
    }
    public void chat_with_friends()
    {
        System.out.println("Chatting with neighbours");
    }
    public abstract void cook(); 

}

---

package chennai.velachery;

public class Child1 extends Parent1{

    public static void main(String[] args) {
//      Child1 ch = new Child1(); 
//      ch.cook();
//      ch.chat_with_friends(); 
//      ch.watch_tv();
//      ch.work();

        Child1 ch = new Child1(); 
        //Dynamic Binding 
        //Parent Class Reference points to Child class Memory
        Parent1 parent = new Child1();  

        parent.watch_tv();
        parent.chat_with_friends();
        parent.cook();
        //parent.work(); 
    }
    public void watch_tv()
    { //Runtime Polymorphism
        System.out.println("Watching OTT");
    }

    @Override
    public void cook() {
        // TODO Auto-generated method stub
        System.out.println("Cooking");

    }

    public void work()
    {
        System.out.println("Java Projects");
    }

}

Java 接口

Java中的接口是类的蓝图。它有静态常量和抽象方法。

Java中的接口是一种实现抽象的机制。 Java接口中只能有抽象方法，不能有方法体。它用于在Java中实现抽象和多重继承。

换句话说，你可以说接口可以有抽象方法和变量。它不能有方法体。

Java接口也代表IS-A关系。

它不能像抽象类一样被实例化。

为什么使用Java接口？

使用接口主要有三个原因。下面给出了它们。

如何声明接口？

接口是使用interface关键字声明的。它提供了完全的抽象；表示接口中的所有方法都以空体声明，并且所有字段默认都是public、static和final。实现接口的类必须实现接口中声明的所有方法。

*界面：*

接口是一组具有空体的相关方法
100% 抽象：

语法：

    abstract class Employee  
    {  
    abstract void work();  
    }   

示例：

package chennai.velachery;

public abstract class Parent {

    abstract void getJob();

    void studyWell()
    {
        System.out.println("Focus On Maths, Science"); 
    }
    static void display()
    {
        System.out.println("Hi");
    }
    public static void main(String[] args) {
        Parent.display();
//      Parent pp = new Parent(); 
//      pp.display();
//      pp.studyWell(); 
//      pp.getJob();

    }



}

参考：https://www.javatpoint.com/interface-in-java

Java 中的扩展与实现：

在Java中，extends关键字用于继承父类的所有属性和方法，而implements关键字用于实现接口中定义的方法。

**
extends 和implements 关键字**

之间的区别

Java 中的“extends”关键字

在Java中，extends关键字用于指示正​​在定义的类是通过继承从基类派生的。所以基本上，extends关键字用于将父类的功能扩展到子类。在Java中，由于二义性，多重继承是不允许的。因此，一个类只能扩展一个类以避免歧义。

package chennai.velachery;

public class Child extends Parent {


    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Child ch = new Child(); 
        ch.getJob();
        ch.studyWell();
        Child.display();
    }

    @Override //Annotation : Metadata
    //Data about data
    void getJob() {
        // TODO Auto-generated method stub

    }


}

Java 中的“implements”关键字

在Java中，implements关键字用于实现接口。接口是一种特殊类型的类，它实现了完全抽象并且仅包含抽象方法。要访问接口方法，接口必须由另一个类使用implements关键字“实现”，并且方法需要在继承接口属性的类中实现。由于接口没有方法的实现，因此一个类可以一次实现任意数量的接口。

/

package chennai.velachery;

public abstract class Parent1 {

    public void watch_tv()
    {
        System.out.println("Watching TV");
    }
    public void chat_with_friends()
    {
        System.out.println("Chatting with neighbours");
    }
    public abstract void cook(); 

}

参考：https://www.geeksforgeeks.org/extends-vs-implements-in-java/

示例：

    abstract class Employee  
    {  
    abstract void work();  
    }   

---

package chennai.velachery;

public abstract class Parent {

    abstract void getJob();

    void studyWell()
    {
        System.out.println("Focus On Maths, Science"); 
    }
    static void display()
    {
        System.out.println("Hi");
    }
    public static void main(String[] args) {
        Parent.display();
//      Parent pp = new Parent(); 
//      pp.display();
//      pp.studyWell(); 
//      pp.getJob();

    }



}

抽象类 u>
0 到 100% 抽象

抽象关键字

非静态变量

可以在场

* *与界面
100% 抽象
没有抽象关键字
所有变量都是静态的，
最终公开

以上是关键词：抽象扩展，接口实现的详细内容。更多信息请关注PHP中文网其他相关文章！