Java抽象类和接口类

java抽象类与接口类

1.抽象类

在面向对象中所有的对象都是通过类来描绘的,但是所有的类不是都用来描绘对象的

在一个类中如果没有足够的信息来描绘一个对象,那么这样的类就叫做抽象类

1.1为什么需要抽象类

当一个父类知道子类具有什么方法,但是不知道子类如何去实现一个方法,那么这时候就用到了抽象类

下面是一个动物类,猫和狗类重写了动物类的run方法

  class Animal{
        public void run(){
            System.out.println("这是动物类的run方法")
        }
     class Cat extends Animal{
         //继承动物类 重写run方法
         @Override
         public void run(){
             System.out.println("猫会跑")
         }
     }
      class Dog extends Animal{
          @Override
          public void run(){
              System.out.println("狗会跑")
          }
      }
        
    }@[TOC](这里写自定义目录标题)

猫类和狗类重写了动物类,都知道动物类表示任何动物的一个行为,所以动物类不能被实例化

此时我们可以通过abstract关键字来声明抽象类

  abstract class Animal{
        
    }

1.2抽象方法

在抽象类中,如果没有子类没有实现抽象的方法,那么将会报错,也可以将子类变为抽象类

  abstract class Cat extends Animal{
        
    }

抽象方法注意事项:

抽象方法不能是 final、static 和 native 的；

抽象方法不能是私有的，即不能用 private 修饰。

因为抽象方法一定要被子类重写，私有方法、最终方法以及静态方法都不可以被重写，

抽象方法不能使用 private、final 以及 static 关键字修饰。而 native 是本地方法，它与抽象方法不同的是，它把具体的实现移交给了本地系统的函数库，没有把实现交给子类，因此和 abstract 方法本身就是冲突的。

2.接口类

2.1概念

java中的接口是一系列方法的集合,一些行为的特征,是对行为的抽象化

2.2为什么需要接口:

java是单继承,也就是说一个类只能继承一个父类,那么想继承多个呢,这时候就用到了接口类

2.3接口的定义

通过 interface关键字声明一个接口

public interface Onepeople{
        
    }

public表示在任何包的任何类使用

在接口主体中可以定义常量和方法的声明:

    public interface People{
        final String man = "is a man";
        void run();
        void eat();
    }

在接口中必须全部是抽象方法,不能具体实现方法,在接口中默认方法都为public abstract 所以接口方法无需声明

public abstract

在接口中也可以声明常量 在接口中默认的常量声明为 public ,static, final

2.4实现接口

implements 用于实现接口的声明,如果需要实现多个接口类名用逗号分割

   public class Myperson implements People,Onepeople{
        
    }  

下面是一个人实现People接口:

 public class Oneperson {
        @Override
        public void run(){
            System.out.println("一个人可以跑");
        }
        
        @Override
        public void eat(){
            System.out.println("一个人也可以好好吃饭");
        }
        //可以通过:接口.常量名 来调用接口的常量
        String personName = People.man;
    }

接口之间也是可以存在继承关系:

  public  interface Interface1 {
    	final String name = "一个人";
    	void run();
    }
    public interface Interface2 extends Interface1 {
        void eat();
    }

当一个类实现接口将会继承所有的抽象方法:

public class Myclass implements Interface2 {
        @Override
        public void eat(){
            System.out.println("一个人也可以好好吃饭");
        
        }
        @Override
        public void run(){
            System.out.println("一个人也可以跑步");
        }
    }

一个接口也可以继承多个父接口 需要逗号进行分割:

    public interface Myinterface01{
        void run();
    }
    public interface Myinterface02{
        void eat();
    }
    public interface Myinterface03 extends Myinterface01, Myinterface02{
        void abstractinterface03();
    }

当一个类同时实现extends 和implements 时,implements需要放在后面

    public class Myclass01 extends Person implements Myinterface03{
        
    }

2.5接口默认方法和静态方法

在jdk1.8以后可以定义默认方法和静态方法 ,实现接口的时候可以不用实现默认方法和静态方法

 public interface Myinterface1{
    	
        void run();
        //接口默认方法
        default void eat(){
            System.out.println("这是接口的默认方法");
        }
        //接口静态方法
        static void go(){
            System.out.println("这是接口的静态方法");
        }
    }

默认方法,静态方法的重写和实现:

1.接口默认方法不需要default声明

2.默认方法可以 通过 接口名.super.默认方法名 调用

3.静态方法不可以重写,直接 接口名.静态方法名 调用

   public class person implements Myinterface1{
        @Override
        public void run(){
            Myinterface1.go();
            System.out.println("接口的跑方法");
        }
        @Override
        public void eat(){
            Myinterface1.super.eat();
            System.out.println("接口的默认吃方法");
        }
    }

接口类和抽象类的区别

1.接口是通过interface关键词修饰的 而抽象类是通过abstract关键字修饰的

2.从设计层面来说，抽象是对类的抽象，是一种模板设计，而接口是对行为的抽象，是一种行为的规范。

3.抽象类中抽象方法只有声明没有具体体现所以无法实例化抽象类

4.抽象类和普通类一样，同样可以拥有成员变量和普通的成员方法。

5.接口方法默认修饰符是 public，抽象方法可以有 public 、protected 和 default 这些修饰符（抽象方法就是为了被重写所以不能使用 private 关键字修饰！

6.接口中只能有 final 和static变量 不能有其他变量 ,而抽象类可以

7.在jdk8中允许 接口有默认方法和静态方法,在jdk9中允许有私有方法