JavaSE之面向对象编程二

JavaSE之面向对象编程二

前面我们介绍了面向对象编程的包、继承、重写等方法，这次我们来看看抽象类和接口。

目录

1.抽象类

抽象类是无法进行实例化的：

抽象类里面也可以包含和普通类里面一样的成员和方法

因为不能被实例化，所以这个抽象类其实只能被继承，其最大的作用也是被继承

如果一个普通类继承了一个抽象类，那么这个普通类当中需要重写这个抽象类当中所有的抽象方法

如果一个抽象类A继承了一个抽象类B，那么这个抽象类A可以不实现抽象父类B的抽象方法

结合上一点，当A类再次被一个普通类继承后，那么A和B这两个抽象类当中的抽象方法必须被重写

抽象类和抽象方法都不能被Final修饰

2.接口

接口中的方法，不能有具体的实现，如果要实现，前面必须加default

接口中可以有static的方法，不加public也可以，因为接口中的方法默认都是public的

接口里面的抽象方法默认都是public abstract的

接口不能通过new关键字来实例化

类和接口之间的关系是通过implements来实现的，但当一个类实现一个接口的时候，必须重写

接口当中的抽象方法

接口中的方法，默认是public static final修饰的

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

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

        接口和接口之间可以用extends来 *** 作它们之间的关系，此时意为拓展。一个接口B通过extends拓展另一个接口C的功能，此时当一个类D通过implements实现这个接口B的时候，此时重写的方法不仅仅是B的方法，还有他从C接口拓展来的功能。

---

1.抽象类

比如我们定义一个父类，但这个父类在程序运行的过程中并没有起一定的作用，主要的工作都是由其子类的方法来完成的，像这种没有实际工作的方法, 我们可以把它设计成一个 抽象方法(abstract
method), 包含抽象方法的类我们称为 抽象类(abstract class)

下面我们通过代码来具体看看抽象类的实现过程

abstract class Shape {
      public abstract void draw();//抽象方法，没有{}，不能实行具体代码
}

//包含抽象方法的类，用abstract修饰，表示这是一个抽象类

抽象类是无法进行实例化的：

抽象类里面也可以包含和普通类里面一样的成员和方法

abstract class Shape {
   public int a;
    public void func(){
        System.out.println("普通测试方法");
    }
}

因为不能被实例化，所以这个抽象类其实只能被继承，其最大的作用也是被继承

​
abstract class Shape {
  public abstract void draw();//抽象方法
}
//继承抽象类之后要重写抽象类里面的方法
class Rect extends Shape{
    @Override
    public void draw() {
        System.out.println("李");
     }
}

​

如果一个普通类继承了一个抽象类，那么这个普通类当中需要重写这个抽象类当中所有的抽象方法 如果一个抽象类A继承了一个抽象类B，那么这个抽象类A可以不实现抽象父类B的抽象方法

比如：

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

abstract class A extends  Shape{

    public abstract void funcA();
}

结合上一点，当A类再次被一个普通类继承后，那么A和B这两个抽象类当中的抽象方法必须被重写

abstract class Shape {
  
    public abstract void draw();//抽象方法
}

abstract class A extends  Shape{

    public abstract void funcA();
}

class B extends A{
    @Override
    public void funcA() {

    }
    @Override
    public void draw() {
   }
}

抽象类和抽象方法都不能被Final修饰

抽象类的作用：抽象类存在最大意义就是为了被继承.抽象类本身不能被实例化, 要想使用, 只能创建该抽象类的子类. 然后让子类重写抽象类中的抽象方法.有些同学可能会说了, 普通的类也可以被继承呀, 普通的方法也可以被重写呀, 为啥非得用抽象类和抽象方法呢?确实如此. 但是使用抽象类相当于多了一重编译器的校验.使用抽象类的场景就如上面的代码, 实际工作不应该由父类完成, 而应由子类完成. 那么此时如果不小心误用成父类了,使用普通类编译器是不会报错的. 但是父类是抽象类就会在实例化的时候提示错误, 让我们尽早发现问题。
 

2.接口

        接口是抽象类的更进一步. 抽象类中还可以包含非抽象方法, 和字段. 而接口中包含的方法都是抽象方法, 字段只能包含静态常量
 

接口实现举例：

使用interface来实现，即interface IA{ }

代码实现：

interface  IShape{
    public abstract void draw();//抽象方法
}

接口中的方法，不能有具体的实现，如果要实现，前面必须加default

interface  IShape{
    public abstract void draw();//抽象方法
    //方法不能实现，如要实现，必须加default
    default public void func(){

        System.out.println("fassa");
    }
    default public void func2(){

        System.out.println("fassa");
    }
}

接口中可以有static的方法，不加public也可以，因为接口中的方法默认都是public的

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

   //可以有static的方法,不加public也可以，因为接口中的方法默认都是public的
    public static void  funStatic(){

        System.out.println("fafa");
    }
}

接口里面的抽象方法默认都是public abstract的 接口不能通过new关键字来实例化

类和接口之间的关系是通过implements来实现的，但当一个类实现一个接口的时候，必须重写 接口当中的抽象方法

interface  IShape{
    public abstract void draw();//抽象方法
    
    default public void func(){

        System.out.println("fassa");
    }
 }
class Rect implements IShape{
    @Override
    public void draw() {
      System.out.println("♦");
    }
     @Override
    public void func(){
     System.out.println("重写接口当中的默认方法");
    }
}

接口中的方法，默认是public static final修饰的

interface IShape {
   void draw();
  public static final int num = 10;
}

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

interface  IShape{
    public abstract void draw();//抽象方法
    
    default public void func(){

        System.out.println("fassa");
    }
}
class Rect implements IShape{
    @Override
    public void draw() {
      System.out.println("♦");
    }
      @Override
      public void func(){
     System.out.println("重写接口当中的默认方法");
    }
   

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

interface  IA { 
    //必须初始化
    int A = 10;
    void funcA();//默认是public abstract修饰的
}
interface IB {
    void funcB();
}
class BClass {

}
//一个类可以通过关键字extends继承一个抽象类或者普通类，但是只能继承一个类，同时，也可以通过implements
//实现多个接口，接口之间只用逗号隔开就好
class AClass extends BClass implements IA ,IB{
    //重写满足的条件是子类中方法的权限一定大于等于父类权限，而现在没有修饰默认是包访问权限，小于public,因此这里应该用public修饰
    public void funcA(){
        System.out.println("A::funcA()");
        System.out.println(A);
    }
    @Override
    public void funcB() {
        System.out.println("A::funcA()");
    }
}

        接口和接口之间可以用extends来 *** 作它们之间的关系，此时意为拓展。一个接口B通过extends拓展另一个接口C的功能，此时当一个类D通过implements实现这个接口B的时候，此时重写的方法不仅仅是B的方法，还有他从C接口拓展来的功能。

   

interface IA1{
    void funcA();
}
//接口和接口之间可以使用extends来 *** 作他们的关系，此时意为拓展,
//一个接口B通过extends拓展另一个接口C的功能。此时当一个类D通过implements实现这个接口B的时候。
//此时重写的方法不仅仅是B的方法，还有他从C接口拓展来的功能（方法）

interface IB1 extends  IA1{
    void funB();
}
class C implements IB1{
    @Override
    public void funB() {
        System.out.println("fassa");
    }
    @Override
    public void funcA() {
        System.out.println("erwtyuu");
    }
}