JavaSE 进阶 - 第16章 面向对象（final、抽象类、接口）

1、final关键字——最终的，不可改变的

1.1、final 修饰的类不能被继承
1.2、final 修饰的方法不能被覆盖
1.3、final 修饰的变量只能赋一次值。

1.4、final修饰的引用一旦指向某个对象，则不能再重新指向(new)其它对象，
     但该引用指向的对象内部的数据是可以修改的。

		final Person p2 = new Person();
		//能编译通过
		//p2 指向的对象的属性是可以修改的
		p2.name = "李四";
		System.out.println(p2.name);

		//不能编译通过
		//p2 采用 final 修饰，主要限制了 p2 指向堆区中的地址不能修改(也就是p2 只能指向一个对象)
		//p2 = new Person();

1.5、 final修饰的实例变量，系统不负责赋默认值，要求程序员必须手动赋值。
      这个手动赋值，可以在变量后面直接赋值，也可以在构造方法中赋值，选一种！

	public class Person{
		private String name;

		// 错误: 变量 age 未在默认构造器中初始化
		//final int age;
		final int age = 20;
		
		//可以通过，以下代码联合起来，weight变量也是只赋了一次值
		final double weight;
		public Person(){  //当自己写了构造方法后，就不会有系统默认赋初始值
			this.weight=80;
			//错误: 可能已分配变量weight。final 修饰的变量只能赋一次值。
			//this.weight=90;  
		}

		public static final String COUNTRY = "中国"; //常量
	
	} 

	回顾：实例变量在什么时候被系统赋默认值？
		在构造方法执行的时被赋值。（new的时候赋值）
		（构造方法详情看第九章笔记最后面）

1.6、final修饰的实例变量一般和static联合使用，称为常量。
	因为final修饰的实例变量赋初始值后，那么永远都不会再改变了，即使是对不同的对象，
	该变量都是相同的值，那么这样的话，也就没必要声明为实例变量了，而且还在堆中浪费内存（实例变量是每个对象一份的）
	那么就用static修饰，成为静态的，存储在方法区（所有对象共用这一关变量），节省内存
		public static final String COUNTRY = "中国";
	
	static final 修饰的变量，称为常量
	常量名建议全部大写，每个单词之间用下划线连接
	实际上，常量和静态变量一样，都存储在方法区，区别在于：
		常量的值不能改变（常量是无法重新赋值的）
	常量一般都是公开的public，    public static final

1.7 构造方法不能被 final 修饰

1.8 会影响JAVA类的初始化:
    final 定义的静态常量调用时不会执行 java 的类初始化方法，
	也就是说不会执行 static 代码块等相关语句，这是由 java 虚拟机规定的。

2、抽象类

• 抽象类的理解：

类到对象是实例化。对象到类是抽象。

1、什么是抽象类？
	类和类之间具有共同特征，将这些共同特征提取出来，形成的就是抽象类。
	类本身是不存在的，所以抽象类无法创建对象《无法实例化》。

	作用：	降低接口实现类对接口实现过程难度!
       		将接口中不需要使用的抽象方法交给抽象类进行完成
      	    这样接口实现类只需要对接口中需要的方法进行重写

				    extends        implements
			接口实现类————————》抽象类——————————》接口

		例如：	
		    我们经常需要使用 【A接口】 中的 a方法，而 【A接口】 中的 b方法、c方法基本不用，如果直接定义【A接口】的【实现类】的话，
			就需要把【A接口】中的3个方法都实现。于是我们可以先定义一个【抽象类】，让其实现【A接口】，并以简单方式对【A接口】中
			a方法以外的其它方法进行实现，即要么是空方法体，要么返回 null，而将 a方法 声明为抽象方法。
			这样，以后再定义【实现类】时就只需要继承自这个通用的【抽象类】，只用重写a方法就好了，无需再实现【A接口】了。
			
			这是一种设计模式，称为“缺省适配器”设计模式。

2、抽象类属于什么类型？
	抽象类也属于引用数据类型。

3、抽象类怎么定义？《能把基础语法先学会》
	语法：
		[修饰符列表] abstract class 类名{
			类体;
		}

4、抽象类是无法实例化的，无法创建对象（new）的，所以抽象类是用来被子类继承的。

5、final和abstract不能联合使用，这两个关键字是对立的。
	final修饰的类是不能被继承的，abstract修饰的类是用来被子类继承的。

6、抽象类的子类可以是抽象类。也可以是非抽象类。

7、抽象类虽然无法实例化，但是抽象类有构造方法，这个构造方法是供子类使用的。

8、抽象类关联到一个概念：抽象方法。什么是抽象方法呢？
	
	抽象方法表示没有实现的方法，没有方法体的方法。例如：
		public abstract void doSome();
	抽象方法特点是：
		特点1：没有方法体，以分号结尾。
		特点2：前面修饰符列表中有abstract关键字。

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

10（五颗星）：一个非抽象的类，继承抽象类，必须将抽象类中的抽象方法进行覆盖/重写/实现。


【注】：到目前为止，只是学习了抽象类的基础语法，一个类到底声明为抽象还是非抽象，
	这个以后慢慢来吧。写代码多的时候，自然就理解了。

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

3、接口的基础语法。

1、接口是一种“引用数据类型”。编译之后也是一个class字节码文件。

2、接口是完全抽象的。（抽象类是半抽象。）或者也可以说接口是特殊的抽象类。

3、接口怎么定义：[修饰符列表] interface 接口名{}
   注意：接口名前面没有class，只有interface
   
4、接口支持多继承。一个接口可以继承多个接口。
	// 定义接口
	interface A{
	}

	// 接口支持继承（一个接口继承另一个接口）
	interface B extends A{
	}

	//支持多继承（一个接口可以继承多个接口）
	interface C extends A, B{
	}

5、接口中只有常量+抽象方法。【常量：值不能改变的变量】

6、接口中所有的元素都是public修饰的

7、接口中抽象方法的public abstract可以省略。

8、接口中常量的public static final可以省略。

9、接口中方法不能有方法体。

10、类和类之间叫做继承，类和接口之间叫做实现。
    继承使用extends关键字完成。
    实现使用implements关键字完成。

11、五颗星（*****） 一个非抽象的类，实现接口的时候，必须将接口中所有方法加以实现（覆盖、重写）。
   【同 2 的第10条，因为接口是特殊的抽象类】

12、一个类可以实现多个接口。
	【联想】对于计算机来说，一个机箱上有多个接口，一个接口是接键盘的，一个接口
		是接鼠标的，一个接口是接电源的，一个接口是接显示器的.....
	
	重点（五颗星*****）：一个类可以同时实现多个接口。

	这种机制弥补了java中的哪个缺陷？
		java中类和类只支持单继承。实际上单继承是为了简单而出现的，现实世界中
		存在多继承，java中的接口弥补了单继承带来的缺陷。
	
	// 实现多个接口，其实就类似于多继承。
	class D implements A,B,C{......

13、继承extends和实现implements可以共存，extends在前，implements在后。

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

14、使用接口，写代码的时候，可以使用多态（父类型引用指向子类型对象）。

4、接口在开发中的作用

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

多态：面向抽象编程，不要面向具体编程。降低程序的耦合度。提高程序的扩展力。
	/*
	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开发原则。
		接口的使用离不开多态机制。（接口+多态才可以达到降低耦合度。）

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

		以后进行大项目的开发，一般都是将项目分离成一个模块一个模块的，
		模块和模块之间采用接口衔接。降低耦合度。

5、类型和类型之间的关系

• 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
  

6、抽象类和接口的区别

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

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

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

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

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

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

这里先透露一个信息：
	以后接口使用的比抽象类多。一般抽象类使用的还是少。
	接口一般都是对“行为”的抽象。

传送门

上一章：JavaSE 进阶 - 第15章 回顾面向对象（8-14）、集成开发工具
下一章：JavaSE 进阶 - 第17章 面向对象（包和访问控制权限）