接口和抽象类

1.1抽象类

package day9.com;
/*
*
* 抽象类：
*   子类可以帮助我们实现，我用子类即可
* 1、不能直接实例化,规范/规定。 不抽象也可以多态
* 2、利用子类实例,子类实例代替父类。用抽象类，用的是它的子类。
* 3、抽象类中可以有抽象方法，也可以没有抽象方法。
* 4、不能有私有的抽象方法。私有的方法子类继承不了，要用子类的方法
* 5、如果一个类中有抽象方法，必须是抽象类。
*
* 一个类实现多样时，让不同的人完成不同实现，就可以考虑抽象类。
* 1、类的生命周期（应有功能）
*       1、初始化
* 最后，你不会有人帮你实现。
*
* */
import java.util.Date;
import java.util.Scanner;
import javax.servlet.Servlet;//接口
import javax.servlet.GenericServlet;//抽象类


public abstract class MyAbstract {
    MyAbstract(){
        //抽象类可以有构造方法。
        //并且必须有，且权限不能是私有，否则无法实例化（必须通过子类实例化,使用子类的实例化对象，
        // 子类实例化对象的重写方法。）
    }
    public static void main(String[] args){
        Date myDate = new Date();
        System.out.println(myDate.getTime());
        System.out.println("ok");


        //1、写了一个匿名类继承抽象类。匿名类必须实现抽象类，使用的是匿名类
                //内部匿名类，不是匿名对象
                //不是完全代表实例化，效率低。
                //编译时产生 MyAbstract$1.class
        //抽象类，接口是架构师，项目经理弄的
                //要求、
                //
//        MyAbstract myAbstract = new MyAbstract() {
//
//            @Override
//              public  void connect() {
//
//            }
//        };


        //想实现数据库连接

    }
    //抽象方法：只有声明方法，没有方法体（方法实现），这个方法必须是公开的，不能是private私有的
//    private abstract void  connect();//抽象方法不能是私有的，权限文体。

    public abstract void  connect();
        //注意区别空实现。

    public abstract int save();

    //可以放一些实用方法，子类继承后可以使用。也可通过实例化的类使用。

    public Object getHelp(){
        System.out.println("这个方法可以帮助子类...");
        return new String();
    }

    //静态方法，直接通过类名使用,不需要实例化
    public static Object get(){
        System.out.println("这个方法可以...，不需要实例化就能使用");
        return new String();
    }
}

1.2抽象类的实现类

package day9.com;

//抽象类的实现类
//以后就用子类代方法替父类抽象方法

//张三精通mysql数据库连接,mysql保存,恰好需要，张三就继承了，然后实现了抽象方法。

import java.util.Random;

public class MyComplete extends MyAbstract {


   /**
    * 此方法用于连接数据库
   */
    //连接数据库的具体操作
    @Override
    public void connect() {
        System.out.println("连接mysql数据库");
    }
/**
 * 此方法保存数据到mysql数据库中，如果返回 1代表保存成功，返回0保存失败
*/
    @Override
    public int save() {
        Random rand = new Random();
        return rand.nextBoolean() ? 1 :0;
    }
}

1.3测试类

package day9;


//抽象类：


import day9.com.MyAbstract;
import day9.com.MyComplete;

public class TestAbstract {
    //
    public static void main(String[] args) {
        MyAbstract myAbstract = new MyComplete();
        myAbstract.connect();
    }
}
//总结：
//1、没有实例化的抽象类，抽象类不能实例化
            //1、为了使用/可以不用(作用是规范子类)，只能实例化子类。
//2、抽象方法只需声明，无需实现，没有方法体。
//3、抽象类不一定要包含抽象方法可以有其它方法，而定义抽象方法的类必须是抽象类
            //1、类有的抽象类都有，类没有的抽象类也有
            //2、接口也有抽象方法。
//4、抽象类包含的抽象方法必须在其子类中被实现，否则该子类也必须是抽象类。
            //1、抽象方法不能是私有的，
            //2、抽象类是规范，或者是规范的规范。
//5、抽象类必须有构造方法供子类实例化对象
            //1、这是每个父类需要遵守的，
            //2、但是由于抽象类不能被实例化，所以若它想被调用，他的构造方法不能是私有的。

//抽象类的作用是，
//1、类有多种实现。一个类定义多种多样，不唯一。
        //用子类就是用的一个实现类。
//2、让别人去实现，制定规范。并不是一个人完成的，只是制定一个规范。
        //让实现类拥有必要的重写方法，这样就能用实现类。


//补充
//1、匿名类实现。编译后产生一个.class文件

 

2.1接口

package day9.org;
//定义接口
//接口定义 interface关键字
//接口继承,
    // 1、可以继承多个接口，效果是合成一套。实现时灵活度不高
    // 2、接口继承关键字extends

@FunctionalInterface
public interface MyInteface extends B,C{
//    public static final int age = 18;
    //属性必须在声明时初始化
        //接口中不允许初始化设定
        //接口没有构造方法
        //接口没有静态代码块--只能初始化静态属性
        //规定public static final；全局静态常量成员属性

    byte FIELD = 7;

//    public static final method();
    //方法不允许被final修饰
        //方法默认类型是public abstract 类型，方法中全部是全局，静态，抽象的。
                //规定，不写也是public abstract。 我就是一套规范。比抽象类更狠。
        //不能有方法体。
    /**
     * method方法功能描述
     * */
    public abstract void method();
    //总结：
    // 1、接口中只有全局，静态，常量，成员属性和全局抽象方法。

    //怎么用，
    // 1、使用接口实现类。接口起到规范作用。和抽象类一样。
    // 2、函数式接口---只有一个抽象方法的接口默认为函数式接口，
        //关键字@FunctionalInterface -- 帮助我们看是否只有一个抽象方法。
        //函数式接口可以使用一些关键字。

    //所有的实现类，init() destroy方法都一样，减少代码长度，所以接口实现了通用的方法
    //实现的方法就不是抽象方法，一个接口有多个方法也可以是函数式接口。
    //需要实现接口子类，通过接口子类使用

    default void init(){
        System.out.println("初始化成功");
    }
    //静态方法可以通过接口名调用。

    static void destroy(){
        System.out.println("对象销毁成功");
    }
}

interface B{}

interface C{}

//java1.8 对接口新的调整
//1.接口如果有且只有一个抽象方法，此接口自动编译为函数式接口
        //1.可以使用lambda表达式，作为参数直接添加，不能写实现类。
//2新增了实现方法（（1）默认实现方法（2）静态实现方法）

2.2接口实现类

非抽象类为实现类

package day9.org;

//接口实现类是非抽象类

public class InterfaceImpl implements MyInteface{

    //实现类必须重写接口的抽象方法
    //抽象类也可以继承接口
    /**
     * method的注解
     * */
    @Override
    public void method() {
        System.out.println("实现类实现了method方法");
    }
}

抽象类为实现类

package day9.org;

//接口的实现类是抽象类
//接口的规范可以是规范的规范。

public abstract class InterfaceImpl2 implements MyInteface{

}

 

2.3测试类

package day9;

import day9.org.InterfaceImpl;
import day9.org.MyInteface;

public class TestInterface {
    public static void main(String[] args){
        MyInteface myInteface = new InterfaceImpl();
        //使用实现类方法，
        myInteface.method();
        //使用接口的静态方法
        MyInteface.destroy();
        //通过实例化类使用接口的实现方法
        myInteface.init();

        //lambda表达式函数式接口
        //返回值为空可以写一个{}
        MyInteface inter = ()-> {
            System.out.println("lambda表达式实例化接口");
            System.out.println("此实例化对象的method方法已经被重写，就是用的这个方法");
        };
        //使用method()方法
        inter.method();

    }
}

//接口类似国家的宪法，
//各种法律不能违反宪法，不按照宪法

//接口和抽象类的总结
//1、只是制定，没有执行

 

补充

接口是功能（飞，走）和常量(public static final )的集合

类和子类是 is 的关系

接口和实现类是 has || like a的关系