JAVASE23天从入门到精通_Day08

抽象类

抽象类 : 比类更为抽象的类叫抽象类 / 被abstract修饰的类叫抽象类

格式:
    public abstract class 类名{

    }

抽象类的成员

	抽象类的成员:
        // 抽象类中可以什么都没有!!只要被abstract修饰.那么类就是抽象类
        1. 成员变量 : 可以有
        自定义常量(被final修饰的变量就是常量) : 可以有
        2. 构造方法: 可以有
        3. 成员方法: 可以有
        4. 静态成员方法: 可以有
        5. 抽象方法 : 可以有

        结论: 抽象类比普通类多一个抽象方法!!(抽象方法必须存在于抽象类中)

抽象方法的格式

格式:
	权限修饰符 abstract 返回值类型 方法名(形参列表);

注意 : 
	1. static 关键字 不可以和 abstract 一起使用!!
    2. 抽象方法在抽象类中可以有多个!

抽象类的使用步骤

1. 准备一个普通类,让此类去继承抽象父类
2. 
	方案1: 在子类中重写父类中所有的抽象方法
	方案2: 把子类也变成抽象类
	//抽象方法必须存在于抽象类中
3. 	
    方案1 : 创建子类对象,并调用抽象类中成员或者重写后的抽象方法
    方案2 : 还是要准备一个普通类重写子类中继承下来的抽象方法,再创建子类的子类对象
    
    注意:
        1. 抽象类虽然有构造方法但是不可以创建抽象类的对象    

final 关键字

final : 修饰符 -> 最终的

作用的地方:
	类 : 最终的类 -> 被final修饰的类没有子类
	成员变量 : 最终的变量 -> 被final修饰的成员变量不能改变 -> 自定义常量
		自定义常量: 1. 必须赋值 2. 加上 static 关键字 3. 常量名: 全部大写,多个单词之间用 _ 分割
			//JAVA_HOME
			格式 :  public static final 数据类型 变量名 = 初始化值;
	成员方法 : 最终的方法 -> 被final修饰的成员方法不能重写
	局部变量 : 最终的局部变量 -> 被final修饰的局部变量不能改变 -> 局部常量(实时final)

接口概述

接口 : interface -> 比抽象类更抽象的类叫接口 (接口是一种特殊的类/接口也是一种引用数据类型)
    
抽象方法不但可以在抽象类中还可以存活于接口中!!    
    
使用接口的场景 : 如果一个抽象类中全都是抽象方法,那么就可以不定义抽象类,而是定义接口!
    	(如果一个类中全都是抽象方法,就可以把这个类改定义成接口!)

接口的思想

生活中的接口 : USB接口,Type-c接口,API(Application Programming Interface) 应用程序编程接口....
    
接口的主要思想 不是 连接! 
    1. 而是提供规范!!  
    2. 而是功能拓展!!
    
既然是规范,最重要的一个环节是 公开 !!
    对应代码 : 接口中的成员最重要的关键字  : public !

接口的定义格式

格式:
    public interface 接口名{//接口名的命名规范和类名一致!!

    }

接口和类的关系

类和类的关系 : 继承 和 没有关系 -> extends -> 单一继承多层继承

类和抽象类的关系 : 继承 和 没有关系 -> extends -> 单一继承多层继承
	//抽象类一般都是作为父类存在

接口和类的关系 : 实现 和 没有关系 -> implements -> 多实现(叔叔,干爹)
	//接口一般都是作为父接口存在
    
接口和接口的关系 : 继承 和 没有关系 -> extends -> 多继承


格式:
	//父接口
    public interface InterFu{

    }

	public interface InterDie{

    }

    public class Fu{

    }

	//子类继承父类实现多个接口
    public class Zi extends Fu implements InterFu,InterDie{//多实现

    }

	//接口和接口之间是多继承
	public interface InterA{

    }
	
	public interface InterB{

    }

	public interface InterC extends InterA,InterB{

    }

使用接口的场景 : 如果一个抽象类中全都是抽象方法,那么就可以不定义抽象类,而是定义接口!

JDK8之前版本接口的成员和使用(重要)

    JDK8之前版本接口的成员和使用(重要):
        成员变量 : 不可以有
        自定义常量 : 可以有
            接口中的成员变量默认被 public static final 所修饰 变成 自定义常量!!
        构造方法 : 不可以有 -> 肯定不能创建接口对象
        普通方法 : 不可以有
        抽象方法 : 可以有
            接口中所有的成员方法默认被 public abstract 修饰 变成 抽象方法!!
            
    结论 : JDK8之前接口中只允许有 自定义常量  和 抽象方法!!  
        
如何使用接口:
	1. 创建一个普通类(实现类),实现父接口
	2. 在实现类中要么重写父接口中所有的抽象方法/要么把实现类自己也变成抽象类(不推荐)
	3. 在使用接口的地方,创建实现类对象:
    	实现类对象可以调用重写后的抽象方法;
    	实现类对象可以调用接口中的自定义常量(更推荐使用接口名直接访问自定义常量)

JDK8版本接口的成员和使用(掌握)

JDK8版本的接口成员和使用:
	1. 自定义常量
	2. 抽象方法
	-----新增-----
    3. 默认方法
    	格式:
            public default 返回值类型 方法名(形参列表){
				方法体;
                return 值;
            }
		默认方法默认被 : public 修饰
        默认方法,实现类可以选择性重写!!(当实现类实现的多个父接口中有同名的默认方法,实现类必须手动重写父接口中的默认方法)
       	默认方法的调用 : 实现类对象调用默认方法
    4. 静态方法
    	格式:
			public static 返回值类型 方法名(形参列表){
				方法体;
                return 值;
            }
		静态方法默认被: public 修饰
		静态方法,实现类不能重写!!
        接口中的静态方法 只能使用接口名直接调用 ,不可以使用实现类对象调用(特殊!!)

JDK9版本接口的成员和使用(了解)

JDK9版本的接口成员和使用:
	1. 自定义常量
	2. 抽象方法
	3. 默认方法
   	4. 静态方法
   	-----新增-----
    5. 私有方法(只为接口中的默认方法和静态方法服务)   外界不能访问
        普通私有方法
        	格式:
				private 返回值类型 方法名(形参列表){
                    方法体;
                }
        静态私有方法(专门服务静态方法的)
            格式:
				private static 返回值类型 方法名(形参列表){
                    方法体;
                }

接口和抽象类的区别

	接口	抽象类
成员变量	没有	有
自定义常量	有(public static final)	有
构造方法	没有	有(不能创建对象)
普通方法	没有	有
抽象方法	有(public abstract)	有
默认方法	有(JDK8开始)	没有
静态方法	有(JDK8开始)	有

使用上:
	1. 和实现类的关系 --> 接口是 实现  / 抽象类是 继承
	2. 实现类都需要重写父接口/抽象父类中所有的抽象方法 或者 把实现类自己变成抽象类;
	3. 实现类选择性重写父接口中的默认方法 / 实现类选择性重写抽象父类中的普通方法