抽象类

第一：抽象类怎么定义？在class前添加abstract关键字就行了。
第二：抽象类是无法实例化的，无法创建对象的，所以抽象类是用来被子类继承的。
第三：final和abstract不能联合使用，这两个关键字是对立的。
第四：抽象类的子类可以是抽象类。也可以是非抽象类。
第五：抽象类虽然无法实例化，但是抽象类有构造方法，这个构造方法是供子类使用的。
第六：抽象类中不一定有抽象方法，抽象方法必须出现在抽象类中。
第七：抽象方法怎么定义？
public abstract void doSome();
第八（**五颗星）：一个非抽象的类，继承抽象类，必须将抽象类中的抽象方法进行覆盖/重写/实现。*

上图为对抽象类的理解

面试题（判断题）：java语言中凡是没有方法体的方法都是抽象方法。
        不对，错误的。
        Object类中就有很多方法都没有方法体，都是以“;”结尾的，但他们
        都不是抽象方法，例如：
            public native int hashCode();
            这个方法底层调用了C++写的动态链接库程序。
            前面修饰符列表中没有：abstract。有一个native。表示调用JVM本地程序。

/*
	抽象类：

	1、抽象类中不一定有抽象方法，抽象方法必须出现在抽象类中。

	2、重要结论：重要结论五颗星*****（必须记住）
	一个非抽象的类继承抽象类，必须将抽象类中的抽象方法实现了。
	这是java语法上强行规定的，必须的，不然编译器就报错了。
			
	这里的覆盖或者说重写，也可以叫做实现。（对抽象的实现。）

*/
public class AbstractTest02{
	public static void main(String[] args){
		// 能不能使用多态?
		// 父类型引用指向子类型对象。
		Animal a = new Bird();  // 向上转型。（自动类型转换）

		// 这就是面向抽象编程。
		// 以后你都是调用的a.XXXX
		// a的类型是Animal，Animal是抽象的
		// 面向抽象编程，不要面向具体编程，降低程序的耦合度，提高程序的扩展力。
		// 这种编程思想符合OCP原则。
		/*
			分析以下：
				编译的时候这个move()方法是谁的？
				运行的时候这个move()方法又是谁的？
		*/
		a.move();

		// 多态（当对多态不是很理解的时候，以后写代码能用多态就用多态。慢慢就理解了。）
		Animal x = new Cat();
		x.move();
	}
}

// 动物类（抽象类）
abstract class Animal{

	// 抽象方法
	public abstract void move();
}

// 子类（非抽象的）
// 错误: Bird不是抽象的, 并且未覆盖Animal中的抽象方法move()
/*
class Bird extends Animal{
}
*/

class Bird extends Animal{
	// 需要将从父类中继承过来的抽象方法进行覆盖/重写，或者也可以叫做“实现”。
	// 把抽象的方法实现了。
	public void move(){
		System.out.println("鸟儿在飞翔！");
	}
}

class Cat extends Animal{
	public void move(){
		System.out.println("猫在走猫步！");
	}
}

// 如果Bird是抽象类的话，那么这个Animal中继承过来的抽象方法也可以不去重写/覆盖/实现。
/*
abstract class Bird extends Animal{
}
*/
	

/*
	有些内容不要死记硬背，讲讲道理。
	分析：
		Animal是父类，并且是 抽象的。
		Animal这个抽象类中有一个抽象方法move。

		Bird是子类，并且是 非抽象的。
		Bird继承Animal之后，会将抽象方法继承过来。

*/

接口

接口的基础语法

1、接口是一种“引用数据类型”。
2、接口是完全抽象的。
3、接口怎么定义：[修饰符列表] interface 接口名{}
4、接口支持多继承。
5、接口中只有常量+抽象方法。
6、接口中所有的元素都是public修饰的
7、接口中抽象方法的public abstract可以省略。
8、接口中常量的public static final可以省略。
9、接口中方法不能有方法体。
10、一个非抽象的类，实现接口的时候，必须将接口中所有方法加以实现。
11、一个类可以实现多个接口。
12、extends和implements可以共存，extends在前，implements在后。
13、使用接口，写代码的时候，可以使用多态（父类型引用指向子类型对象）。

/*
	接口的基础语法：
		1、类和类之间叫做继承，类和接口之间叫做实现。
		别多想：你仍然可以将"实现"看做“继承”。
		继承使用extends关键字完成。
		实现使用implements关键字完成。

		2、五颗星（*****）：当一个非抽象的类实现接口的话，必须将接口中所有的
		抽象方法全部实现（覆盖、重写）。
*/
public class Test02{
	public static void main(String[] args){
		//错误: MyMath是抽象的; 无法实例化
		//new MyMath();

		// 能使用多态吗？可以。
		//Animal a = new Cat();

		// 父类型的引用指向子类型的对象
		MyMath mm = new MyMathImpl();
		// 调用接口里面的方法（面向接口编程。）
		int result1 = mm.sum(10, 20);
		System.out.println(result1);

		int result2 = mm.sub(20, 10);
		System.out.println(result2);
	}
}

// 特殊的抽象类，完全抽象的，叫做接口。
interface MyMath{
	double PI = 3.1415926;
	int sum(int a, int b);
	int sub(int a, int b);
}

// 这样没问题
/*
abstract class MyMathImpl implements MyMath {
}
*/

// 编写一个类（这个类是一个“非抽象”的类）
// 这个类的名字是随意的。
//错误: MyMathImpl不是抽象的, 并且未覆盖MyMath中的抽象方法sub(int,int)
/*
class MyMathImpl implements MyMath {
}
*/

//修正
class MyMathImpl implements MyMath {

	//错误：正在尝试分配更低的访问权限; 以前为public
	/*
	int sum(int a, int b){
		return a + b;
	}
	*/

	// 重写/覆盖/实现 接口中的方法（通常叫做实现。）
	public int sum(int a, int b){
		return a + b;
	}

	public int sub(int a, int b){
		return a - b;
	}
}

/*
	接口和接口之间支持多继承，那么一个类可以同时实现多个接口吗？

		对于计算机来说，一个机箱上有多个接口，一个接口是接键盘的，
		一个接口是接鼠标的，一个接口是接电源的，一个接口是接显示器的.....
	

	重点（五颗星*****）：一个类可以同时实现多个接口。

	这种机制弥补了java中的哪个缺陷？
		java中类和类只支持单继承。实际上单继承是为了简单而出现的，现实世界中
		存在多继承，java中的接口弥补了单继承带来的缺陷。
	
	接口A和接口B虽然没有继承关系，但是写代码的时候，可以互转。
	编译器没意见。但是运行时可能出现：ClassCastException

	之前有一个结论：
		无论向上转型还是向下转型，两种类型之间必须要有继承关系，
		没有继承关系编译器会报错。（这句话不适用在接口方面。）
		最终实际上和之前还是一样，需要加：instanceof运算符进行判断。
		向下转型养成好习惯。转型之前先if+instanceof进行判断。
*/
public class Test03{
	public static void main(String[] args){
		// 多态该怎么用呢？
		// 都是父类型引用指向子类型对象
		A a = new D();
		//a.m2(); // 编译报错。A接口中没有m2()方法。
		B b = new D();
		C c = new D();

		// 这个编译没问题，运行也没问题。
		// 调用其他接口中的方法，你需要转型（接口转型。）
		B b2 = (B)a;
		b2.m2();

		// 直接向下转型为D可以吗？可以
		D d = (D)a;
		d.m2();

		M m = new E();
		// 经过测试：接口和接口之间在进行强制类型转换的时候，没有继承关系，也可以强转。
		// 但是一定要注意，运行时可能会出现ClassCastException异常。
		// 编译没问题，运行有问题。
		//K k = (K)m;
		if(m instanceof K){
			K k = (K)m;
		}
	}
}

interface K{
}

interface M{
}

class E implements M{
}

// --------------------------------------------------------------------

interface X{
}
interface Y{
}
interface Z extends X,Y{ //接口和接口支持多继承。
}

//------------------------------------------------------------------

interface A{
	void m1();
}

interface B{
	void m2();
}

interface C{
	void m3();
}

// 实现多个接口，其实就类似于多继承。
class D implements A,B,C{
	// 实现A接口的m1()
	public void m1(){
		
	}
	// 实现B接口中的m2()
	public void m2(){
		System.out.println("m2 ....");
	}
	// 实现接口C中的m3()
	public void m3(){
	
	}
}

以下为继承与实现同时存在时的情况：

/*
	继承和实现都存在的话，代码应该怎么写？
		extends 关键字在前。
		implements 关键字在后。
*/
public class Test04{
	public static void main(String[] args){
		// 创建对象（表面看Animal类没起作用！）
		Flyable f = new Cat(); //多态。
		f.fly();

		// 同一个接口
		Flyable f2 = new Pig();
		// 调用同一个fly()方法，最后的执行效果不同。
		f2.fly();

		Flyable f3 = new Fish();
		f3.fly();
	}
}

// 动物类：父类
class Animal{
}

// 可飞翔的接口（是一对翅膀）
// 能插拔的就是接口。（没有接口你怎么插拔。）
// 内存条插到主板上，他们之间有接口。内存条可以更换。
// 接口通常提取的是行为动作。
interface Flyable{
	void fly();
}

// 动物类子类：猫类
// Flyable是一个接口，是一对翅膀的接口，通过接口插到猫身上，让猫变的可以飞翔。
class Cat extends Animal implements Flyable{
	public void fly(){
		System.out.println("飞猫起飞，翱翔太空的一只猫，很神奇，我想做一只猫！！");
	}
}

// 蛇类，如果你不想让它飞，可以不实现Flyable接口
// 没有实现这个接口表示你没有翅膀，没有给你插翅膀，你肯定不能飞。
class Snake extends Animal{
}

// 想飞就插翅膀这个接口。
class Pig extends Animal implements Flyable{
	public void fly(){
		System.out.println("我是一只会飞的猪！！！");
	}
}

// 鱼（默认实际上是存在继承的，默认继承Object。）
/*
class Fish extends Object implements Flyable{
}
*/
class Fish implements Flyable{ //没写extends，也是有的，默认继承Object。
	public void fly(){
		System.out.println("我是六眼飞鱼（流言蜚语）！！！");
	}
}

接口在开发中的作用

注意：接口在开发中的作用，类似于多态在开发中的作用。

多态：面向抽象编程，不要面向具体编程。降低程序的耦合度。提高程序的扩展力。
/*
public class Master{
public void feed(Dog d){}
public void feed(Cat c){}
//假设又要养其它的宠物，那么这个时候需要再加1个方法。（需要修改代码了）
//这样扩展力太差了，违背了OCP原则（对扩展开放，对修改关闭。）
}
*/

public class Master{
public void feed(Animal a){
// 面向Animal父类编程，父类是比子类更抽象的。
//所以我们叫做面向抽象编程，不要面向具体编程。
//这样程序的扩展力就强。
}
}

接口在开发中的作用？
接口是不是完全的？是。
而我们以后正好要求，面向抽象编程。
面向抽象编程这句话以后可以修改为：面向接口编程。
有了接口就有了可插拔。可插拔表示扩展力很强。不是焊接死的。

主板和内存条之间有插槽，这个插槽就是接口，内存条坏了，可以重新
买一个换下来。这叫做高扩展性。（低耦合度。）

接口在现实世界中是不是到处都是呢？
螺栓和螺母之间有接口
灯泡和灯口之间有接口
笔记本电脑和键盘之间有接口（usb接口，usb接口是不是某个计算机协会制定的协议/规范。）
接口有什么用？扩展性好。可插拔。

接口是一个抽象的概念。

分析：
中午去饭馆吃饭，这个过程中有接口吗？

接口是抽象的。

菜单是一个接口。（菜单上有一个抽象的照片：西红柿炒鸡蛋）

谁面向接口调用。（顾客面向菜单点菜，调用接口。）

谁负责实现这个接口。（后台的厨师负责把西红柿鸡蛋做好！是接口的实现者。）

这个接口有什么用呢？
这个饭馆的“菜单”，让“顾客”和“后厨”解耦合了。
顾客不用找后厨，后厨不用找顾客。他们之间完全依靠这个抽象的菜单沟通。

总结一句话：三个字“解耦合”
面向接口编程，可以降低程序的耦合度，提高程序的扩展力。符合OCP开发原则。
接口的使用离不开多态机制。（接口+多态才可以达到降低耦合度。）

接口可以解耦合，解开的是谁和谁的耦合！！！
任何一个接口都有调用者和实现者。
接口可以将调用者和实现者解耦合。
调用者面向接口调用。
实现者面向接口编写实现。

类型和类型之间的关系：

is a（继承）、has a（关联）、like a（实现）

is a：
Cat is a Animal（猫是一个动物）
凡是能够满足is a的表示“继承关系”
A extends B

has a：
I has a Pen（我有一支笔）
凡是能够满足has a关系的表示“关联关系”
关联关系通常以“属性”的形式存在。
A{
B b;
}

like a:
Cooker like a FoodMenu（厨师像一个菜单一样）
凡是能够满足like a关系的表示“实现关系”
实现关系通常是：类实现接口。
A implements B

抽象类和接口有什么区别？

在这里我们只说一下抽象类和接口在语法上的区别。
至于以后抽象类和接口应该怎么进行选择，通过后面的项目去体会/学习。

    抽象类是半抽象的。
    接口是完全抽象的。

    抽象类中有构造方法。
    接口中没有构造方法。

    接口和接口之间支持多继承。
    类和类之间只能单继承。

    一个类可以同时实现多个接口。
    一个抽象类只能继承一个类（单继承）。

    接口中只允许出现常量和抽象方法。
    

以后接口使用的比抽象类多。一般抽象类使用的还是少。
接口一般都是对“行为”的抽象。

接口在开发中的实现举例：

AmericCooker.java:

//西餐厨师
// 实现菜单上的菜
// 厨师是接口的实现者。
public class AmericCooker implements FoodMenu{

	// 西红柿炒蛋
	public void shiZiChaoJiDan(){
		System.out.println("西餐师傅做的西红柿炒鸡蛋！");
	}

	// 鱼香肉丝
	public void yuXiangRouSi(){
		System.out.println("西餐师傅做的鱼香肉丝！");
	}
}

ChinaCooker.java:

//中餐厨师
// 实现菜单上的菜
// 厨师是接口的实现者。
public class ChinaCooker implements FoodMenu{

	// 西红柿炒蛋
	public void shiZiChaoJiDan(){
		System.out.println("中餐师傅做的西红柿炒鸡蛋，东北口味！");
	}

	// 鱼香肉丝
	public void yuXiangRouSi(){
		System.out.println("中餐师傅做的鱼香肉丝，东北口味！");
	}
}

FoodMenu.java:

/*
	接口：菜单，抽象的
*/
public interface FoodMenu{

	// 西红柿炒蛋
	void shiZiChaoJiDan();

	// 鱼香肉丝
	void yuXiangRouSi();

}

Customer.java

// 顾客
public class Customer{
	// 顾客手里有一个菜单
	// Customer has a FoodMenu!（这句话什么意思：顾客有一个菜单）
	// 记住：以后凡是能够使用 has a 来描述的，统一以属性的方式存在。
	// 实例变量，属性
	// 面向抽象编程，面向接口编程。降低程序的耦合度，提高程序的扩展力。
	private FoodMenu foodMenu; 
	
	// 如果以下这样写，就表示写死了（焊接了。没有可插拔了。）
	// 中餐厨师
	//ChinaCooker cc;

	// 西餐厨师
	//AmericCooker ac

	// 构造方法
	public Customer(){
	}
	public Customer(FoodMenu foodMenu){
		this.foodMenu = foodMenu;
	}

	// setter and getter
	public void setFoodMenu(FoodMenu foodMenu){
		this.foodMenu = foodMenu;
	}
	public FoodMenu getFoodMenu(){
		return foodMenu;
	}

	// 提供一个点菜的方法
	public void order(){
		// 先拿到菜单才能点菜
		// 调用get方法拿菜单。
		//FoodMenu fm = this.getFoodMenu();
		// 也可以不调用get方法，因为在本类中私有的属性是可以访问
		foodMenu.shiZiChaoJiDan();
		foodMenu.yuXiangRouSi();
	}
}

/*
	Cat is a Animal，但凡满足is a的表示都可以设置为继承。
	Customer has a FoodMenu，但凡是满足has a的表示都以属性的形式存在。
*/

/*
class Address{
	String city;
	String street;
	String zipcode;
}

class User{
	int id;

	// 和这个一样。
	// String是一个类。
	// name是变量名。
	// name是一个引用。
	String name;

	// Address是一个类名。
	// 这就是一个变量。
	// 实例变量。
	Address addr; // addr是一个引用。是一个变量。

	public static void main(String[] args){
		// 局部变量
		//Address addr;
		//addr = new Address();

		// 合并。
		Address addr = new Address();

		User u = new User();
		u.id = 100;
		u.name = "zhangsan";
		u.addr = new Address();

		System.out.println(u.addr.city); // null
		System.out.println(u.addr.street); // null
		System.out.println(u.addr.zipcode); // null
	}
}

//“自己”类
// MySelf has a Friend;
class MySelf{
	// 你这个对象，应该有一个朋友对象的电话号码。
	// 电话号码就是一个对象的内存地址。联系你朋友的时候，打电话。
	// f是一个引用。f默认值是null，是null表示，你没有朋友。
	Friend f;

	public MySelf(){
	
	}
	//通过构造方法能不能给你一个朋友对象。
	public MySelf(Friend f){
		this.f = f;
	}

	public static void main(String[] args){
		// 创建朋友对象
		Friend f = new Friend(); //朋友对象有了

		// 创建对象的同时交朋友。
		MySelf m2 = new MySelf(f);


		// 创建自己对象
		// 目前还没有交朋友。
		MySelf m = new MySelf(); //自己对象
		// 交朋友
		m.f = f; // 把朋友的地址给了你。
	}
}

// “朋友”类
class Friend{

}

*/

Test.java:

public class Test{
	public static void main(String[] args){

		// 创建厨师对象
		//FoodMenu cooker1 = new ChinaCooker();
		FoodMenu cooker1 = new AmericCooker();

		// 创建顾客对象
		Customer customer = new Customer(cooker1);

		// 顾客点菜
		customer.order();
	}
}