第四周笔记

1.抽象

如果父类当中的方法不确定如何进行方法体实现，那么这就应该是一个抽象方法。

1.1 抽象方法和抽象类的格式

抽象方法： 就是加上abstract关键字，然后去掉大括号，直接分号结束。
抽象类： 抽象方法所在的类，必须是抽象类才行，即在class之前写上abstract即可。

public abstract class Animal {
	//这是一个抽象方法，代表吃东西，但是具体吃什么不确定。
	public abstract void eat();
} 

1.2 抽象方法和抽象类的使用

1. 不能直接创建new抽象类对象。
2. 必须用一个子类来继承抽象父类。
3. 子类必须覆盖重写抽象父类当中所有的抽象方法。
   覆盖重写（实现）：子类去掉抽象方法的abstract关键字，再补上方法体大括号。
4. 创建子类对象进行使用。

public class Cat extends Animal {
	public void eat() {
		System.out.println("我吃鱼");
	}
}

public class AnimalEat {
	public static void main(String[] args){
		//Animal animal = new Animal(); //错误写法，不能直接创建抽象类对象
		Cat cat = new Cat();
		cat.eat();
	}
}

1.3 抽象方法和抽象类的注意事项

1. 抽象类不能创建对象，如果创建，编译无法通过而报错，只能创建其非抽象子类的对象。
2. 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
4. 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错，除非该子类也是抽象类。

2. 接口概述

接口就是一种公共的规范标准。只要符合规范标准，就可以通用。

1. 接口就是多个类的公共规范。
2. 接口是一种引用数据类型，最重要的内容就是其中的：抽象方法。

2.1 接口的定义基本格式

public interface 接口名称 {
	// 接口内容
}

注：换成了关键字interface之后，编译生成的字节码文件仍然是：.java 和 .class

2.2 接口的抽象方法定义

在任何版本的Java中，接口都能定义抽象方法。

public interface InterfaceAbstract{
	//抽象方法，这些写法都对
	public abstract void methodAbs1();
	abstract void methodAbs2();
	public void methodAbs3();
	void methodAbs4();
}

注意事项：

1. 接口当中的抽象方法，修饰符必须是两个固定的关键字：public、abstract。
2. 这两个关键字修饰符，可以选择性省略。
3. 方法的三要素，可以随意定义。

2.3 接口的抽象方法使用

使用步骤：

1. 接口不能直接使用，必须有一个“实现类”来“实现”该接口。

//格式：
public class 实现类名称 implements 接口名称 {
	//内容
}

2. 接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。
   实现：去掉abstract关键字，加上方法体大括号。
3. 创建实现类的对象，进行使用。

快捷键 Alt + Enter 可直接将需要的抽象方法列出

public class RealizeClass implements InterfaceAbstract {
	@Override
	public void methodAbs1() {
		System.out.println("这是第一个");
	}
	@Override
	public void methodAbs2() {
	System.out.println("这是第二个");
	}
	@Override
	public void methodAbs3() {
	System.out.println("这是第三个");
	}
	@Override
	public void methodAbs4() {
	System.out.println("这是第四个");
	}
}

public class Interface {
	public static void main(String[] args){
		//错误写法，不能直接new接口
		//InterfaceAbstract inter = new InterfaceAbstract(); 

		//创建实现类的对象使用
		RealizeClass inter = new RealizeClass(); 
		inter.methodAbs1();
	}
}

注意事项：如果实现类并没有覆盖重写接口当中的所有抽象方法，那么这个实现类自己就必须是抽象类。

2.4 接口的默认方法定义

从java 8开始，接口里允许定义默认方法。

//格式：
public default 返回值类型 方法名称(参数列表) {
	方法体
}

2.5 接口的默认方法使用

1. 接口的默认方法，可以通过接口实现类对象，直接调用。
2. 接口的默认方法，也可以被接口实现类进行覆盖重写。

接口：

public interface InterfaceDefault {
	//抽象方法
	public abstract void methodAbs();
	//默认方法(public可省略)
	public default void methodDefault() {
		System.out.println("默认方法");
	}
}

接口实现类：

public class InterfaceDefaultA implements InterfaceDefault {
	@Override
	public void methodAbs() {
		System.out.println("抽象方法");
	}
}

使用：

public class Demo1Interface {
	public static void main(String[] args){
		// 创建实现类对象
		InterfaceDefaultA a = new InterfaceDefaultA();
		a.methodAbs(); // 调用抽象方法，实际运行的是实现类

		a.methodDefault(); //调用默认方法，如果实现类没有，会向上找接口
	}
}

2.6 接口的静态方法定义

从Java 8开始，接口当中允许定义静态方法

//格式（public可省略）
public static 返回值类型 方法名称(参数列表) {
	方法体
}

2.7 接口的静态方法使用

注意： 不能通过接口实现类的对象来调用接口当中的静态方法。应通过接口名称，直接调用其中的静态方法。
格式： 接口名称.静态方法名(参数);

接口：

public interface InterfaceStatic {
	//静态方法
	public static void methodStatic() {
		System.out.println("静态方法");
	}
}

接口实现类：

public class InterfaceStaticA implements InterfaceStatic {
}

使用：

public class Demo2Interface {
	public static void main(String[] args){
		/*错误写法
		InterfaceStaticA a = new InterfaceStaticA();
		a.methodStatic(); */
		
		//直接通过接口名称调用静态方法
		InterfaceStatic.methodStatic();
	}
}

2.8 接口的私有方法定义

问题描述：
若需抽取一个公有方法，来解决多个默认方法之间重复代码的问题，这个公有方法不应该让方法类实现，应该是私有化的。
解决方法：
从Java 9开始，接口当中允许定义私有方法

1. 普通私有方法，解决多个默认方法之间代码重复的问题

private 返回值类型 方法名称(参数列表) {
	方法体
}

2. 静态私有方法，解决多个静态方法之间代码重复的问题

private static 返回值类型 方法名称(参数列表) {
	方法体
}

2.9 接口的私有方法使用

public interface InterfacePrivate {
	public default void methodDefault1() {
		methodCommonDefault();
	}
	public default void methodDefault2() {
		methodCommonDefault();
	}
	private void methodCommonDefault(){
		//默认方法重复代码；
	}
	
	public static void methodStatic1() {
		methodCommonStatic();
	}
	public static void methodStatic2() {
		methodCommonStatic();
	}
	private static void methodCommonStatic(){
		//静态方法重复代码；
	}
}

2.10 接口的常量定义和使用

接口当中也可以定义“成员变量”，但是必须使用 public static final三个关键字进行修饰。从效果上看，这其实就是接口的“常量”。

格式： public static final 数据类型 常量名称 = 数据值；
备注： 一旦使用了final关键字进行修饰，就不可改变

public interface MyInterfaceConst {
	//这其实是一个常量，一旦赋值，不可以修改
	public static final int NUM = 10;
}

注意：

1. 接口中的常量，可以省略public static final。
2. 接口中的常量，必须进行赋值，不能不赋值，若不明确赋值，则默认为0（不可改变）。
3. 接口中常量的名称使用完全大写的字母，用_进行分割，例：NUM_OF_STUDENT。

2.11 接口之间的多继承

1. 类与类之间是单继承的，直接父类只有一个。
2. 类与接口之间是多实现的，一个类可以实现多个接口。
3. 接口与接口之间是多继承的。

注意事项：

1. 多个父接口当中的抽象方法如果重复，没关系。
2. 多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，并且带着default关键字。

2.12 总结

1. 接口没有静态代码块或者构造方法的。
2. 一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。

//格式
public class InterfaceImpl implements InterfaceA, InterfaceB {
}

3. 如果实现类所实现的多个接口中，存在重复的抽象方法，那么实现类只需覆盖重写一次即可。
4. 如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。
5. 如果实现类所实现的多个接口当中，存在重复默认方法，那么实现类必须要对冲突的默认方法进行覆盖重写。
6. 一个类如果它的直接父类当中的方法和接口当中的方法产生了冲突，优先使用父类当中的方法。