12. 抽象类和接口

1.abstract:抽象的,可以用来修饰类和方法

类和抽象类和接口之间的区别
1：如果一个类继承了一个抽象类，则它必须实现那个抽象类的所有抽象方法，除非它自己也声明为abstract类
1：接口都是抽象方法
2：一个普通类实现接口，就必须将该接口的所有方法都实现
3：抽象类实现接口，可以不用实现接口的方法
4：一个类同时可以实现多个接口（理解为接口是对于Java单继承机制的一种补充）
5：接口不能继承其它的类，但是可以继承多个接口
6：接口的方法可以不需要实现，但是抽象类需要

1.1:抽象类:用abstract修饰的类叫抽象类.
	1.1.1:抽象类的特征:
			1.1.1.1:抽象类不能实例化(不能创建对象).
			1.1.1.2:抽象类有构造方法,构造供子类调用.
			1.1.1.3:抽象类中既可以有0个到多个抽象方法,也可以有0个到多个非抽象方法.
	1.1.2:抽象类的适用场景:
			1.1.2.1:当一个类创建对象时没有任何意义,这个类就可以定为抽象类（其实就是作为模板类来使用）;
			1.1.2.2:当一个类有一个抽象方法时,这个类必须定为抽象类.
	1.1.3:抽象类的作用:
			1.1.3.1:让子类继承,简化代码,实现代码复用性;
			1.1.3.2:规定子类必须拥有的行为.

1.2:抽象方法:用abstract修饰的方法叫抽象方法.
	1.2.1:抽象方法的特征:
			1.2.1.1:抽象方法没有方法体(连方法的大括号都没有).
			1.2.1.2:抽象方法必须让子类实现(重写),除非子类也是抽象类或接口,就可以让孙子类去实现.
			1.2.1.3:抽象方法必须定在抽象类中.
	1.2.2:抽象方法的适用场景:当一个方法无法确定具体实现,就可以将这个方法定
			为抽象方法.
	1.2.3:抽象方法的作用:规定子类必须拥有的行为.

1.3:注意事项:
	1.3.1:final和abstract不可以连用来同时修饰类或者方法.
	1.3.2:final修饰的类不能有abstract方法.
	1.3.3:abstract类可以有抽象方法.
	1.3.4:static和abstract不能同时修饰方法.
	1.3.5:static和final可以同时修饰方法.

2.扩展修饰符的总结:

3.接口:站在逻辑角度来说接口是一种特殊抽象类.接口也是一种引用数据类型.

3.1:接口定义:接口表示一种规范,一种约定,表示一种扩展功能.
	3.2:声明接口的关键字:interface
	     实现接口的关键字:implements
	3.3:接口特征:
		3.3.1:接口中方法全是抽象方法,而且不用abstract修饰,系统会默认用public abstract修饰.(在jdk1.8后,接口中还可以有静态方法).
		3.3.2:接口变量全是静态常量,静态常量不用static final修饰,系统会默认用public static final修饰接口中变量.
		3.3.3:接口不能实例化,接口中没有构造方法.
		3.3.4:接口中抽象方法必须让子类去实现,除非子类也是抽象的.
		3.3.5:一个类如果既有父类又有父接口,先继承父类,再实现父接口.
		3.3.6:类与类之间是继承的关系,类与接口之间是实现的关系,接口与接口之间是继承的关系.
		3.3.7:一个类只能继承一个父类,但是可以实现多个接口,所以从某种程度上来说,接口弥补java单继承的缺陷.
		3.3.8:一个接口可以继承多个接口.
	3.4:接口作用:提高程序可扩展性.

4.接口分类:

4.1:普通接口:接口中可以有静态常量也可以没有,可以有抽象方法也可以没有.
4.2:常量群接口:接口中全是静态常量.
4.3:标志性接口:接口中什么东西都没有,只表示具有某种功能.eg:Serializable.

5.抽象类 VS 接口

5.1:相同点:
		5.1.1:都不能实例化.
		5.1.2:都可以有抽象方法,也可以有静态常量.
		5.1.3:它们的抽象方法必须让子类去实现,除非子类是接口或抽象类,就让孙子类去实现.
		5.1.4:都是引用数据类型.
	5.2:不同点:
		5.2.1:作用不同:抽象类的作用提高代码复用性和规定子类必须拥有行为;
					接口表示一种扩展功能,它的作用提高程序扩展性.
		5.2.2:父子关系不同:一个类只能继承一个抽象类类;
					但是一个类可以实现多个接口.
		5.2.3:构造方法不同:抽象类中有构造方法,可以让子类调用;
						接口中没有构造方法.
		5.2.4:内容不同:抽象类中可以有任何方法,也可以有变量,常量,静态常量;
					  接口中只能有抽象方法(在jdk1.8之后可以有静态方法),接口中只能有静态常量.
		5.2.5:修饰符不同:抽象类中抽象方法必须用abstract修饰,抽象类中静态常量必须用public static final修饰;接口中抽象方法可以不写public abstract修饰,系统会默认给方法加public abstract.接口中静态常量可以不写public static final修饰,系统会默认给接口中静态常量加public static final.
		5.2.6:使用场景不同:子类共同拥有属性和方法或子类必须拥有行为,就可以声明抽象类中;子类的扩展功能或可有可无的功能就可以声明接口中.

接口和类之间的区别是：假如你有一套的业务。比如房子项目里面有桌子方法和电脑方法地板方法等等去实现，你要把这些业务要发布到一个合作的软件上他需要调用里面的方法。如果你把实现类直接给他就会有暴露的风险，你就必须专门一个类暴露出去，然后去继承你的实现方法也就是说你的实现类就成为了父类，其实这样一点作用都没有改暴露的还是会暴露，如果子父类是同一个方法名，他只会调用子类，如果方法名不一样，这和你继承就没有关系了盖保利还是会暴露。

public class test4_3 {
    public static void main(String[] args) {
        test4_1 test4_1 = new test4_1();
        int a=1;
        test4_1.b(a);
    }
}



public class test4_1 extends test4_2{
    public void a(){
        System.out.println("bbbbbb");
    }
}





public class test4_2 {
    public void a(int a){
        if ("1".equals(a)){
            System.out.println("aaaaaa");
        }

    }

    public void b(int a){
        if ("1".equals(a)){
            System.out.println("aaaaaa");
        }

    }
}

接口就不一样了：第一不会暴露你的实现类的业务方法，还避免了单继承可以当需要业务拓展的时候还可以继承别的接口

public interface test5 extends test6{
    public String c();
}



@Component
public class test5_1 implements test5{
    @Override
    public String c() {
      return "2222220";
    }

    @Override
    public String a() {
        return "2222221";
    }

    @Override
    public String b() {
        return "2222222";
    }
    
}


public interface test6 {
    public String a();

    public String b();

}




@RunWith(SpringRunner.class)
@SpringBootTest
public class a{

    @Autowired
    private test5 teat;
    
    @Test
    public void c(){
        String c = teat.c();
        System.out.println(c);
    }
}