07天-07-面向对象(final关键字)
l final：最终。作为一个修饰符：
1) 可以修饰类、函数、变量；
2) final修饰的类不能被继承。为了避免被继承，被子类复写功能。例如：String类；
3) 被final修饰的方法不能被重写；
4) 被final修饰的变量时一个常量只能赋一次值，既可以修饰成员变量，又可以修饰局部变量。
当在描述事物时，一些数据的出现值是固定的，那么这是为了增加阅读性，都给这些值取名字，方便阅读。而这个值不需要改变，所以加上fianl修饰。作为常量，常量的书写规范：所有字符都大写，如果由多个单词组成，单词间通过_连接。
5) 内部类定义在类中的局部位置上，只能访问该局部被final修饰的局部变量。
07天-08-面向对象(抽象类)
l 什么时候使用抽象类？
当多个类中出现相同功能，但是功能主题不同，这时可以进行向上抽取。只抽取功能定义，儿不抽取功主体。
l 抽象类的特点：
1) 抽象方法一定在抽象类中；
2) 抽象方法和抽象类都必须被abstract关键字所修饰；
3) 抽象类不可以用new创建对象。因为调用抽象方法没有意义；
4) 抽象类中的方法要被占用，必须由子类复写所有的抽象方法后，建立子类对象调用。如果子类只覆盖了部分抽象方法，那么盖子类还是一个抽象类；
l 抽象类和一般类没有太大的不同。
该类如何描述事物，就如何描述事物，只不过，盖世五出现了一些看不懂的东西。这些不确定的部分也是该事物的功能，需要明确出现，但是无法定义主体，就通过抽象方法来表示。
l 抽象类的特殊之处：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。
l 抽象类代码演示：
abstract class YoungPerson {
abstract void eat();
abstract void sleep();
}
abstract class Student extends YoungPerson{
private Stringname;
public Student(){
super();
}
public Student(String name){
this.name = name;
}
abstract void study();
public void excise1(){
if(this.name!=null){
System.out.println(name+"跑早操！");
}else{
System.out.println("跑早操！");
}
}
public static void excise2(){
System.out.println("做课间操！");
}
}
public class BaseTest9 extends Student{
public BaseTest9(){
super();
}
public BaseTest9(String name){
super(name);
}
public static void main(String[] args){
//new Student();//抽象类不可以创建对象
BaseTest9.excise2();
BaseTest9 test = new BaseTest9("haha");
test.excise1();
}
public void study(){
System.out.println("正在学习中！");
}
public void eat(){
System.out.println("正在就餐中！");
}
public void sleep(){
System.out.println("正在午睡中!");
}
}
上面的代码展示了以下几个功能：
1) 抽象类可以继承抽象类；
2) 抽象类中既可以定义抽象方法，也可以定义一般方法；
3) 底层类继承一个抽象父类，如果抽象父类还继承了另外一个抽象类，那么底层类必须复写父类的抽象方法和父类的父类的抽象方法，缺一不可；
4) 抽象类不可以创建对象。
07天-11-面向对象(模版方法模式)
l 什么是模板方法？
在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分再使用不确定的部分，这时就将不确定的部分暴露出去，由该类的子类去完成。
l 模板方法设计模式演示：
/*
需求：获取一段程序的运行时间。
原理：或称程序开始和结束的时间并相减既可。
*/
abstract class GetTime{
publicfinal void getTime(){//用final修饰该方法，限定子类不能复写该方法。
long start = System.currentTimeMillis();
runcode();
long end = System. currentTimeMillis();
System.out.println(“毫秒：”+(end-start));
}
public abstractvoid runcode();
}
class SubTime extends getTime{
publicvoid runcode(){
for(int i =0;i<4000;i++){
System.out.print(i);
}
System.out.println();
}
}
public class TimeDemo{
publicstatic void main(String[] args){
SubTime s = new SubTime();
s.getTime();
//GetTime g = new GetTime();//抽象类不能实例化对象。
}
}
07天-12-面向对象(接口)
l 接口格式：
interface 接口名{}
l 接口中的成员修饰符是固定的。
1) 成员常量：public static final
2) 成员函数：public abstract
3) 记住：接口中的成员都是public的。
l 接口的出现将“多继承”通过另外一种形式体现出来，即“多实现”。
l 接口的初期理解：可以认为是一个特殊的抽象类。
当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。
l 接口是不可以创建对象的，因为有抽象方法。需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化对象。否则子类还是一个抽象类。
l 接口可以实现多继承，其他类不可以。下面的代码正确：
interface A{
publicstatic final int num = 3;
voidmethod1();
}
interface B{
voidmethod2();
}
interface C extends A,B{
voidmethod3();
}
l 接口可以被类多实现，也是对多继承不支持的转换形式。Java支持多实现。
接上面的代码：
class D implements A,B{
publicvoid method1(){}
public voidmethod2(){}
public staticvoid main(String[] args){
D test = new D();
System.out.println(test.num);
System.out.println(A.num);
}
}
//编译该文件时，会生成3个类文件(interface是特殊的类文件)。
l 总结接口的特点：
1) 接口是对外暴露的规则；
2) 接口是程序的拓展功能；
3) 接口可以用来多实现；
4) 类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口；
5) 接口与接口之间可以有继承关系（既可以单继承也可以多继承）。
07天-15-面向对象(接口举例体现)
abstract Student{
abstractvoid study();
voidsleep(){
System.out.println(“sleep”);
}
}
interface Smoking{
voidsmoke();
}
class ZhangSan extends Student implementsSmoking{
voidstudy();
publicvoid smoke(){}
}
Class lisi extends Student{
voidstudy(){}
}
//上述代码体现了接口的可拓展性。