Java抽象（方法，类）和Java的接口

一.抽象方法和抽象类(关键字abstract)（没有抽象的成员变量）

1)抽象方法：用abstract修饰的类的方法

2)抽象类：用abstract修饰的类

成员变量：可以有变量，也可以有常量

成员方法：可以有抽象方法，也可以有成员方法

3）抽象方法没有方法体的（也就是没有方法具体的实现部分）

注意：

1）抽象类中抽象方法 强制子类去重写父类的方法

2）抽象类不能实例化对象 ，不能用抽象类创建对象 ，所以-用多态的【父类的引用指向子类的对象】

3）抽象类中不一定有抽象方法，但是抽象方法一定存在抽象类中

4）抽象类中的子类 ，必须重写抽象类的抽象方法

5）抽象类中的抽象方法不需要具体实现的功能。

6）abstract类中可以有构造方法，抽象类的构造方法不能是抽象方法。

7）abstract类和abstract方法都不能用final修饰。

8）代码：

public class Demo01 {  public static void main(String[] args) {      //父类的引用指向子类的对象    Animal animal=new Cat();    animal.eat();    animal.fun();    //打印 猫吃鱼}}/* * 动物  eat * 猫类 eat:鱼 *  *///abstract class Person /*class Person{    // 抽象类中不一定有抽象方法     // public  void fun()    //抽象方法一定存在抽象类中     public  abstract void fun() {    }}*/ abstract class Animal{ final   int number=10;     public Animal() {         System.out.println("我是父类的抽象方法");     }     public void fun() {         System.out.println("我是成员方法");     }      //抽象类中的抽象方法     //第一种写法 abstract public void eat();     //第二中写法      public abstract void eat() ;      } class Cat extends Animal{    @Override    public void eat() {        System.out.println("猫吃鱼");    }}

9）abstract与那些关键字不能共存

1.不能与static共存

static修饰方法，用类名去调用。

abstract修饰抽象方法没有方法的实现，没有实现部分的方法，只能是方法的声明，不能直接调用，所以不能共存

2.不能final共存

final修饰方法不能重写。

abstract修饰方法就是为了子类方法的重写，所以不能被共存

3.不能与private共存

private修饰方法，只能本类去访问private修饰的方法，而子类访问不到，谈不到重写

10）代码

public class Demo02 {    public static void main(String[] args) {        //利用多态创建子类对象         BiXieJianBu y=new YBQ();         y.ziGong();         BiXieJianBu l=new LPZ();         l.ziGong();    }} abstract class BiXieJianBu{        abstract void ziGong();       public abstract void fun(); } class YBQ extends BiXieJianBu{      @Override    public void ziGong() {        // TODO Auto-generated method stub        System.out.println("用刀自宫");    }      @Override    public void fun() {    } } class LPZ extends BiXieJianBu{      @Override    public void ziGong() {        System.out.println("用锤子自宫");    }      @Override    public void fun() {        System.out.println();    } }

二.Java接口（是一个抽象类型，抽象方法的集合，不是类）

1.用==interface关键字==修饰的叫做接口

2.只有抽象方法(没有成员方法）和常量，没有构造方法（==因为接口不是类==）

3.形式：

interface 接口名{}

代码

interface InterA （接口名）{}

4.接口的特点

1）接口中只能声明抽象的方法，成员常量

interface InterA {    public static final int num=10;    public abstract void print();}

注：接口中 系统会默认将

成员变量 写成 int num(其实前面有 public static)

成员方法 写成 void print()；//方法名 其实前面是(public abstract)

这些都被系统默认的，但是自己最好填写上

2）接口中不能有构造函数，所以也不能被实例化（谁去用接口 ，就要去强制你去实现接口中的方法）。—–不能被实例化，可以使用多态的方法是创建实现类的对象。

3）关系

1. 类和类的关系

类和类之间是继承关系，分为单继承和多层继承

2.类和接口的关系

类和接口之间是==实现==关系,不是继承关系,可以单实现,也可以多实现

3.接口和接口的关系

接口和接口之间可以单继承,也可以多继承

4.代码

public class Demo03 {    public static void main(String[] args) {        InterA a=new Person();        a.print();        System.out.println(InterA.num);}}interface InterA {    public static final int num=10;    public abstract void print();}class Person implements InterA{ //实现接口的方法    @Override    public void print() {        // TODO Auto-generated method stub        System.out.println(num);        System.out.println("我是人类的打印");    }}interface InterX{     public  abstract void fun();}interface InterY{     public  abstract void fun1();}//接口和接口之间 可以单继承 也可以多继承interface InterZ extends InterX,InterY{}//接口的多实现/*class Car implements InterX , InterY {    @Override    public void fun1() {        // TODO Auto-generated method stub        System.out.println("我是fun1");    }    @Override    public void fun() {        // TODO Auto-generated method stub        System.out.println("我是fun");    }}*/