接口与抽象方法(学习笔记)

抽象方法

抽象方法:就是加上abstract关键字,然后去掉大括号,没有方法体!!!(但是默认方法是有方法体的)
形式:形如一下形式都可以是抽象方法
public abstract void methodA();
abstract void methodB();
public void methodC();
void methodD();
抽象类:抽象方法所在的类,必须是抽象类.在class前加上abstract

使用方法:
    1.抽象类不能通过new来创建,必须要通过实现的方法
    2.必须用一个子类继承抽象父类
    3.子类必须覆盖重写(Override)抽象父类当中所有的抽象方法
    4.创建子类对象进行使用
==================================================================
一个抽象类不一定含有抽象方法,只要保证抽象方法所在类是抽象的即可
抽象类可以有构造方法,是供子类创建对象时,初始化父类成员使用的

接口

接口就是多个类的公共规范
接口是一种引用数据类型,最重要的内容就是其中的:抽象方法
定义一个接口:
    public interface 接口名称{
        //接口内容
        //接口定义的抽象方法   
        //修饰符固定两个关键字: public abstract
        //这两个关键字可以选择性省略
    }
接口的使用:
    接口不能直接使用(new不可以用),必须有一个"实现类"来"实现"该接口
        格式:
            public class 实现类名称 implements 接口名称{
                //接口的所有抽象方法都要被'覆盖重写'来进行'实现'
                //去掉abstract关键字,加上方法体大括号
                //创建实现类的对象,进行使用
            }
===========================================================================
接口注意事项:
1.接口是没有静态代码块或者构造方法的    
2.一个类的直接父类是唯一的,但是一个类可以同时实现多个接口(这是一种变相的多继承)
  public class A /* extends Object (这个就是直接父类)*/implements B , C {}  
  同时接口可以继承多个接口
  public interface A extends B,C { } 
3.如果实现类所实现的多个接口中有重复的[抽象方法],对于实现类来说,只需覆盖重写一次即可
4.如果实现类所实现的多个接口中有重复的[默认方法],那么实现类一定要对冲突的默认方法进行重写(因为默认方法可以被重写)
5.如果接口继承多个父接口中,存在重复[抽象方法],那么对接口来说不会产生冲突,因为反正都只是接口中的抽象方法,但对于实现类来说,只需要重写一次即可
  如果接口继承多个父接口中,存在重复的[默认方法],那么子接口必须对冲突的默认方法进行重写
  例:public interface A{ 
          abstract void print();
          default void write() {
              System.out.println("默认方法A");
    	}
     }
     public interface B{ 
         abstract void print();
         default void write() {
    		System.out.println("默认方法B");
    	}
     }
     public interface C extends A,B{
         //接口C继承了接口A,B,就相当于接口C拥有接口A和B的抽象方法,即使方法体中没有抽象方法
         //因为存在重名的抽象方法,所以只会继承一个
         //abstract void print();
         //但是由于接口A和B中存在重名的默认方法write(),
         //所以必须选择一个默认方法进行覆盖重写,
         //并且这个重写的方法前必须加上default修饰符.,因为接口中的default关键字不能省略
         @Override
        	default void write() {
    		System.out.println("重写的默认方法");
    	} 
     }
     public class Demo implements C{
         //一个Demo类,implements接口C,就要实现接口C中的所有抽象方法
         //同时接口C还存在一个默认方法,可以不需要实现
         Demo demo = new Demo();
         demo.print(); //调用实现的抽象方法
         demo.write(); //调用接口C的默认方法
         
         @Override
         public void print(){
             //实现这个抽象方法
             System.out.println("一个抽象方法");
         }
     }
6.如果实现类没有覆盖重写所有接口中的所有抽象方法,那么实现类就必须是一个抽象类 

接口中的三种方法(默认,静态,抽象)

interface InterfaceB{ //定义一个接口B
    	void print();
}
interface InterfaceC{ //定义一个接口C
    	void write();
}
interface InterfaceA extends InterfaceB,InterfaceC{ //接口的关系是多继承的,接口A可以继承接口B,C
    	//默认方法一定是public的,但是这个修饰符可以省略
    	//(默认方法)被default修饰的方法是可以有方法体的,并且不需要被实现(但是可以被接口实现类进行覆盖重写)
    	default void hello() {
    		System.out.println("这是一个默认方法");
    	}
    	//(静态方法)使用static关键字修饰接口方法,并且实现类不能实现这个方法
    	static void haha() {
    		System.out.println("这是一个静态的接口方法");
	}
	//(抽象方法)这是一个没有实现的接口方法,所以没有方法体,只能通过实现来调用
	public abstract void hi();
     //接口中的常量,可以省略public static final,这其实是个常量,一旦赋值,不可改变
     //格式public static final 数据类型 常量名称 = 数据值; 
     //常量名称使用完全大写的字母,用下划线分隔
     public static final int NUM=10;
}
public class Demo implements InterfaceA { //类可以实现多个接口
	public static void main(String[] args) {
		Demo demo = new demo();
		demo.hi();//调用重写的抽象方法
        demo.hello();//调用默认方法,这个方法并没有被实现,但是也可以调用,如果实现类中没有,会向上找接口
		InterfaceA.haha();//使用 接口名.方法名来对实现类进行调用(不能通过实现类的对象来调用接口中的静态方法)
    	System.out.println("常量方法的调用,值为:"+InterfaceA.NUM);
   }
	@Override
	public void hi() {//进行方法实现
		System.out.println("这是一个要被实现的方法");	
	}
    @Override
	public void hello() {
		System.out.println("实现类覆盖重写了默认方法");
	}
}
=======================================================
目前的版本接口方法中只允许 public, abstract, default, static 这四个修饰符的使用
java9开始允许接口中定义私有方法 private
1.普通私有方法:解决多个默认方法之间重复代码的问题
private void methodDefault(){}
2.静态私有方法:解决多个静态方法之间重复代码的问题
private static void methodStatic(){}