学习Java第六天：1、Java中的抽象类 2、Java中的接口

目录

1、Java中的抽象类

2、Java中的接口

---

1、Java中的抽象类

类 --- 用来描述具有共同性质的一组事务的自定义复合数据类型

类 --- class关键字创建

public class Hello{} --- 类

抽奖类 --- 通过abstract 修饰的java类

public abstract class Hello{} --- 抽象类

1. 为什么要有抽象类？

   例如：坐车收费，出租车有收费功能（1元/公里）

   公交车有收费功能（全程1元）

   出租车/公交车 --- 汽车 --- 收费功能

   出租车 extends 汽车 --- 重写收费功能 --- （1元/公里）

   公交车 extends 汽车 --- 重写收费功能 --- （全程1元）

   我们可以理解为汽车就是一个抽象类，出租车/公交车都是汽车的子类，出租车/公交车就会从汽车中继承来收费功能然后在根据自身的实际情况，重写收费功能就可以得到属于自己的收费功能实现。

   抽象类的子类往往都是同一种类型事物。

   抽象类实际上就是提供同一种类型事物的公共内容，由抽象类的子类根据自身的实际情况，来实现这个抽象类提供的公共内容，这样子类就需要创建这个公共内容，只需要继承来重写一下就好。（子类不关心有没有这个功能，它只需要关心这个功能怎么实现）

1. 抽象类中可以有哪些元素？

   类 --- 实例变量，静态成员变量，构造方法，实例方法，静态方法。

   抽象类 --- 实例变量，静态成员变量，构造方法，实例方法，静态方法，（抽象方法）。

   误区：判断一个类是不是抽象类不看有没有抽象方法。

   方法基本格式：修饰符 返回值 名称（参数）{方法体}

   实例方法：修饰符 返回值 名称（参数）{方法体}

   静态方法：修饰符 static 返回值 名称（参数）{方法体}

   构造方法：修饰符 类名（参数）{方法体}

   抽象方法：修饰符 abstract 返回值 名称（参数）;

   抽象方法 --- 使用abstract修饰的没有方法体的方法

2. 抽象类的具体用法

   1. 抽象类不能new，借助子类访问抽象类中的实例元素。

   2. 普通的java类继承了抽象类，就需要重写抽象类中的所有抽象方法，否则将这个普通的java类改成抽象类。

   3. 抽象类可以继承其他的抽象类，可以不用重写抽象方法。

   4. 利用上转型对象创建出抽象类对象

   5. 抽象类对象可以访问抽象类中的实例变量，类变量，构造方法，实例方法，类方法（抽象方法实际上是子类重写以后的方法）

//抽象类的运用Demo
public abstract class ShuiGuo{
    public abstract void eat();
}
​
public class PingGuo extends ShuiGuo{
    @Override
    public void eat(){
        System.out.println("我是苹果，先削了皮再吃");
    }
}
​
public class XiGuo extends ShuiGuo{
    @Override
    public void eat(){
        System.out.println("我是西瓜，熟了再吃");
    }
}
​
public class NongChang{
    public static ShuiGuo sellShuiGuo(String name){
        ShuiGuo sg = null;
        if(name.equals("苹果")){
            sg = new PingGuo();
        }
        if(name.equalst("西瓜")){
            sg = new XiGuo();
        }
        return sg;
    }
}
 
public class Main{
    public static void main(String[] args){
        System.out.println("你好，你需要点什么？");
        Scanner sc = new Scanner(System.in);
        String name =sc.next();
        ShuiGuo sg = NongChang.SellShuiGuo(name);
        sg.eat();
    }
}

2、Java中的接口

1. 接口

   通过interface关键字修饰的java元素就是接口。

   格式：public interface 接口名{}

   interface 接口名{}

2. 为什么要有接口？

   为了克服java的单继承，接口可以被实现多个

   例如：收费，出租车有收费功能（1元/公里），飞机有收费功能（全程1000元）

   出租车与飞机不是同一类事物，但是有相同的功能

   接口实际上就是提供不同类型事物的公共内容，有接口的子类根据自身的实际情况，来实现这个接口提供的公共内容。这样子类就需要创建这个公共内容，只需要继承来重写一下就好。

3. 接口中的元素

   接口中可以有常量，静态方法，抽象方法

   1. 接口中变量一定是public static final修饰的常量

   2. 接口中的静态方法一定是public修饰的，public可以被省略

   3. 接口中的抽象方法一定是public abstract修饰的，public abstract可以省略

4. 接口的用法

   1. 接口不能new，如果需要访问抽象方法需要实现接口

   2. 类可以通过implements关键字去实现一个、多个接口

      实现一个public class MyClass implements MyInterface{}

      实现多个接口public class MyClass implements MyInterface1,MyInterface...{}

   3. 普通的类去实现一个、多个接口，就需要将每个接口中的抽象方法重写，否则就需要将这个普通的类改成抽象类。

   4. 抽象类去实现一个、多个接口，不需要重写接口中的抽象方法。

   5. 接口可以继承接口，并且可以继承父接口中的所有元素。

   6. 利用接口回调对象创建出接口对象。

   7. 当某一个普通的java类中的方法参数是接口类型的时候，可以传递接口回调对象，也可以是接口库的子类对象。

//接口
public interface TestInterface{
    //静态成员变量
    //接口中变量一定是public static final修饰的常量
    int id = 1001;
    static String name = "zhangsan";
    public int age = 26;
    
    //静态方法
    //接口中的静态方法一定是public修饰的，public可以被省略
    static void staticMethod(){}
    
    //抽象方法
    //接口中的抽象方法一定是public abstract修饰的，public abstract可以省略
    void abstractMethod();
}

1. 接口回调对象

   接口回调对象 --- 接口的子类对象赋值给接口变量（和上转型对象（多态）很类似）

   public interface TestInterface{
       void info();
   }
   public class TestSunClass implements TestInterface{
       @Override
       public void info(){
           System.out.println("接口回调对象测试");
       };
       
       public void test(){
           System.out.println("实现类自己的方法，接口没有");
       };
   }
   public class Main{
       public static void main(String[] args){
           TestInterface t = new TestSunClass();
           //接口回调对象只能访问接口的抽象方法，实际上访问子类重写以后的抽象方法
           t.info();
           //接口回调对象不能访问子类本身的方法，如果要访问就需要强制类型转换
           TestSunClass ts (TestSunClass)t;
           ts.test();
       }
   }

1. 总结：抽象类与接口的区别？

   抽象类	接口
   abstract class	interface
   extends 一个	implements 一个/多个
   提供同类型事物的公共内容	提供不同类型事物的公共内容
   抽象类中的元素实例变量，类变量，构造方法，实例方法，类方法，抽象方法	接口中可以有类变量，JDK8.0类方法，抽象方法，并且都是public修饰的。