base13-抽象类 接口

第十二天 抽象类 接口 abstract

抽象类和接口以及抽象类和接口的区别

1、 抽象类

第一：抽象类如何定义？在class前面加上abstract关键字就行了。
第二：抽象类是无法实例化的，无法创造对象，所以抽象类是用来被子类继承的。
第三：final和abstract不能联合使用，这两个关键字是对立的。
第四：抽象类的子类可以是抽象类，也可以是非抽象类。
第五：抽象类当中有构造方法，供子类使用。例如：super 子类调用父类的构造方法。
第六：抽象类中不一定有抽象方法,抽象方法必须在抽象类当中。
第七：抽象类怎么定义？ 《能把基础语法学会就行》
- 语法：
{修饰符列表} adstract class 类名{
类体；
}

第八：一个非抽象的类，继承抽象类，必须将抽象类中的抽象方法进行覆盖。

当目前未知，只是学习了抽象类的语法，以后在讲解其他的深入内容。

面试题：java语言当中凡是没有方法体的方法都是抽象方法？

不对，错误的。
Object当中就有很多方法没有方法体，都是以；结尾的，但他们都不是抽象方法，例如：
public native int hashCode();
这个方法底层调用的是C++写的动态链接程序。
前面修饰符列表中没有：abstract。有一个native，表示调用JVM本地程序。

2.1、接口的基础语法。

1、接口也是一种引用数据类型。接口生成的也是class字节码文件。
2、接口是完全抽象的。（抽象类是半抽象的。）或者说接口是特殊的抽象类。
3、接口如何定义呢?
  {修饰符列表} interface 接口名{}

4、接口支持多继承，一个接口可以继承多个接口。

5、接口中只包含两部分内容，一部分是：常量，另一部分是：抽象方法。

6、接口中所有的元素都是public修饰的。（都是公开的）

7、接口中的抽象方法定义时：public abstract可以省略不写。

8、接口中的常量可以省略:public static final 可以不写。

9、接口中的抽象方法不能有方法体。

2.2、接口在开发中的作用。

抽象列 abstract

AbstractTest01 语法

/*abstract
      类到对象是实例化，对象到类是抽象。

  抽象类：
    1、什么是抽象类?
      - 类和类之间具有共同特征，将这些共同特征抽象出来，形成的就是抽象类。
      - 类本身是不存在的，所以抽象类无法创造对象，{无法实例化}。

    2、抽象类属于什么类型？
      - 抽象类属于引用数据类型

    3.抽象类怎么定义？ 《能把基础语法学会就行》
      - 语法：
          {修饰符列表}  adstract class 类名{
              类体；
          }

    4、抽象类是无法实例化的，无法创造对象，所以抽象类是用来被子类继承的。

    5、final和abstract不能联合使用，这两个关键字是对立的。
  
    6、抽象类的子类可以是抽象类，也可以是非抽象类。

    7、抽象类里面有没有构造方法？
       - 有，供子类使用。例如：super 子类调用父类的构造方法。

   8、抽象类关联到一个概念：抽象方法？
      - 抽象方法表示没有实现的方法，没有方法体的方法。例如：
       public abstract void doSome();
      抽象方法体特点：
       1、没有方法体，以分号结束。
       2、前面修饰符列表中有abstract关键字。

       * 抽象类中不一定有抽象方法,抽象方法必须在抽象类当中。

*/
public class AbstractTest01{


   public static void main(String[] args){

      //编译报错：Account是抽象的，无法实例化
      //Account a = new Account();
   }

}

abstract class Account{

   public abstract void doSome();

   public static void doOther(){

   }

}


//子类继承抽象类，子类可以实例化对象
/*class CreditAccount extends Account{  
    public CreditAccount(){

      super();
    }
}
*/

//抽象类的子类可以是抽象类吗？

AbstractTest02 面向抽象编程

/*abstract

   抽象类：
     1、一个非抽象类继承抽象类，必须把抽象方法在子类当中实现：
       * 方法覆盖/重写
       

       * 这里的方法覆盖或者说是重写，也可以叫做实现。
       
     2、如果一个抽象类继承抽象类，抽象方法不去实现也可以。
       * 直接方法覆盖/重写
       

*/

public class AbstractTest02{

    public static void main(String[] args) {
        
        Animal a = new Bird();  //面向抽象编程
        //面向抽象编程，不要面向具体编程，降低程序的耦合度，提高程序的扩展力。
        a.move();


        Animal c = new Cat();
        c.move();
    }
}

//动物类【抽象类】
abstract class Animal{

    //抽象方法
    public abstract void move();
}


//子类【非抽象类】
class Bird extends Animal{

    //需要将父类当中继承过来的抽象方法进行覆盖/重写，或者也可以叫做“实现”。
    
    public void move(){

        System.out.println("鸟在飞!!");
    }
}


/*//子类【抽象类】
abstract class Bird extends Animal{

    //需要将父类当中继承过来的抽象方法进行覆盖/重写，或者也可以叫做“实现”。
    
    public abstract void move();
}
*/
class Cat extends Animal{
    public void move(){
        System.out.println("猫在走猫步!!!!");
    }
} 

Test01 案例

public class Test01{
    public static void main(String[] args){

        System.out.println(myMath.PI);

        myMath.PI = 3.15;

    }
}

interface A{

}

interface B extends A{

}

interface myMath{

    //常量
    public static final double PI = 3.1415926;

    double PK = 3.1415926;

    //抽象方法
    //public abstract int sum(int a,int b);

    //接口是抽象方法，可以省略abstract
    int sum(int a,int b);

    //相减的抽象方法
    int sub(int a,int b);
}

接口

Test02 面向接口编程

public class Test02{
    public static void main(String[] args){

        //面向接口编程
        myMath m = new MyMathImpl();


        int result = m.sum(10,20);
        System.out.println(result);

        int result1 = m.sub(10,20);
        System.out.println(result1);
    }
}
//特殊的抽象类，完全抽象的，叫做接口。
interface myMath{
    double PI = 3.1415926;
    int sum(int a,int b);
    int sub(int a,int b);
}


//编写一个类（这个类是一个非抽象的类）
//这个类的名字是随意的
class MyMathImpl implements myMath{

    //实现
  public  int sum(int a,int b){

    return a + b;

    }

    //无法省略public，访问权限的问题，不能更低只能更高
  public int sub(int a,int b){

    return a - b;
  }
}