今天完成的事情：

1.Maven基础学习

a.有的软件安装自带了maven，也就是任务中所谓的外部或者自带，一般情况下在使用前会设置成外部的，版本更新功能更全，idea在setting-maven中的maven home directory里设置

b.然后是设置文件和本地仓库地址的设置，都在同一界面上。在设置文件里也可以设置maven的默认地址，与上面不同的是，上面设置的是idea中使用时默认使用本地地址，这个设置的是maven从网络上下载jar包的保存地址，主要是为了以后维护管理上方便，因为默认地址是C盘，使用起来会有很多顾虑比如重装系统，怕占用太多内存空间，建议设置成一样，方便管理。

c.新建项目：通过new project-maven-creat from archetype-org.apache.maven.archetypes:maven-archetype-quickstart,然后选择参数，在此界面可以更改成非默认的地址等，但是不建议

d.添加jar包，三种方式：第一种直接复制，将下载的啊jar包解压后直接放入项目的lib目录下，此方法不建议使用因为容易报错；第二种通过file-Project Structure-modules-dependencies-+-jars or directorys-选择jar包，第三种比较复杂我也没搞明白原理和意义，可能时为了以后管理方便，具体见http://blog.csdn.net/zwj1030711290/article/details/56678353

e.相关快捷键多熟悉，能用快捷键的操作尽量用快捷键完成。

2.敲一个demo,熟悉重写的操作：一个父类三个子类，每个子类重写父类构造方法和成员方法

public class Employee {
    public String name;
    public int birthMonth;

    public double getSalary(int month){
        if(month==birthMonth){
            return 250;
        }return 0;
        }
    public Employee(String name,int birthMonth){
        this.name=name;
        this.birthMonth=birthMonth;
    }
}

public class SalesEmployee extends Employee {
    int sales;
    double commissiom;
    public double getSalary(int month){
        super.getSalary(month);
        return super.getSalary(month)+sales*commissiom;

    }
    public SalesEmployee(String name,int birthMonth,int sales,double commissiom){
        super(name,birthMonth);
        this.sales=sales;
        this.commissiom=commissiom;
    }
}

public class SalariedEmployee extends Employee {
    int monthlySalary;
    public double getSalary(int month){
        super.getSalary(month);
        return super.getSalary(month)+monthlySalary;

    }
    public SalariedEmployee(String name,int birthMonth,int monthlySalary){
        super(name,birthMonth);
        this.monthlySalary=monthlySalary;
    }
}

public class HourlyEmployee extends Employee {
    int hours;
    int hourSalary;
     public double getSalary(int month){
         super.getSalary(month);
         if(hours>150){
             return super.getSalary(month)+hourSalary*150+(hours-150)*hourSalary*0.5;
         }
         else return super.getSalary(month)+hours*hourSalary;

     }
     public HourlyEmployee(String name,int birthMonth,int hours,int hourSalary){
         super(name,birthMonth);
         this.hours=hours;
         this.hourSalary=hourSalary;
     }
}

public class Demo {
    public static void main(String[]args){
        HourlyEmployee he1=new HourlyEmployee("zhangsan",3,170,10);
        System.out.println(he1.name+"的工资是"+he1.getSalary(3));
        SalesEmployee se1=new SalesEmployee("huer",4,15000,0.3);
        double salary=se1.getSalary(3);
        System.out.println(se1.name+"的工资是"+se1.getSalary(3));
        SalariedEmployee se2=new SalariedEmployee("lisi",5,3500);
        System.out.println(se2.name+"的工资是"+se2.getSalary(3));
    }
}

运行结果为

结论：当父类中没有显式的无参构造，只有有参构造时，子类可以引用此有参构造，也是可以建立子类的；重写的快捷键为ctrl+o，以后多用；整个过程中不需要出现salary,就没必要建立这个变量了，否则反而容易出错；注意getSalary()在父类中的参数个数是一个，所以子类重写时参数个数也只能是一个。

3.对象的转型

a.多态分为对象多态和行为多态，对象多态是指对象具有不同的状态，其是通过对象的转型实现的。

b.对象向上转型：让父类的引用指向子类的对象。

c.对象向下转型：对象向上转型的逆操作，先有向上转型才有向下转型，一般通过强制转换符实现，在对象向下转型时，要先判断堆中的对象是否为目标类型的对象。

d.可以使用instanceof操作符判断对象类型，语法为：myobject instanceof ExampleClass,返回值为布尔类型，如果返回值为true，证明myobject对象时ExampleClass的实例对象，返回false则不是。

e.对象向上转型，让父类的引用作为方法的形参，调用方法时，可以传递子类对象的实参，可以使方法具有一定扩展性和通用性，如下

public class Demo {
    public static void main(String[]args){
        HourlyEmployee he1=new HourlyEmployee("zhangsan",3,170,10);
        System.out.println(he1.name+"的工资是"+he1.getSalary(3));
        SalesEmployee se1=new SalesEmployee("huer",4,15000,0.3);
        double salary=se1.getSalary(3);
        System.out.println(se1.name+"的工资是"+se1.getSalary(3));
        SalariedEmployee se2=new SalariedEmployee("lisi",5,3500);
        System.out.println(se2.name+"的工资是"+se2.getSalary(3));
        printSalary(se1,3);
        printSalary(se2,3);
        printSalary(he1,3);
    }
    public static  void printSalary(Employee employee,int month){
        System.out.println(employee.name+month+"月的工资为："+employee.getSalary(month));
}
}

新增一个方法，形参为父类，而在调用时，对象实参填的是子类的对象名，结果依然可以得到每个对象的工资，就是利用的向上转型

输出结果为

f.对象向上转型，让父类的引用作为方法的返回值类型，实际返回的是子类的对象。

4.final关键字

a.用final修饰的实例变量，保存在堆区中，在定义时必须初始化赋值，不能被修改；用final修饰的静态变量，保存在方法区，也无法被修改。

b.使用final修饰的实例方法，不能被子类重写。

c.子类的对象可以调用继承父类的final方法。

d.使用final修饰的类不能被继承。

e.final修饰的局部变量，一旦被赋值就不能被修改。

f.final修饰方法的形参，在方法体中不能被修改。

g.final修饰引用类型变量，这个引用类型的变量不能指向其他对象，但是可以修改这个对象的属性。

h.使用final修饰了父类的静态方法，由于静态方法本来就无法被继承，所以不存在继承，但是修饰后会约束子类不能定义重名的静态方法。

5.多态

a.多态分为对象多态和行为多态。行为多态是指相同的语句有不同的实现，执行相同的语句有不同的操作。

b.行为多态分为静态多态和动态多态。静态多态是通过方法的重载实现的，在编译阶段就确定了要执行的代码，又称为编译时多态；动态多态是在继承中，子类重写父类的方法，通过父类的引用调用被重写的方法，实际上执行的是子类的方法。

c.动态多态需要满足的条件①继承②方法重写③父类引用指向子类对象④父类引用调用被重写的方法。

d.对于实例变量来说不存在多态，因为只有满足重写方法才可以。

e.子类虽然可以定义和父类同名的静态方法，但是不是重写，所以也就不是多态。

6.抽象类和抽象方法

a.对一组类进行抽象可以形成更高层级的类，更高层级的某个类的操作无法具体实现时，就可以把这个操作用抽象方法来表示，即在方法之前加abstract。

b.含有抽象方法的类必须定义为抽象类，但是抽象类中不一定有抽象方法。抽象方法没有方法体，除了被重写，没有任何意义。承载这个抽象方法的抽象类若不被继承也没有任何意义。

c.如果一个类继承了抽象类，就必须重写抽象类中的全部抽象方法，如果没有重写抽象类中的方法，这个类也需要定义为抽象类。

d.抽象类不能实例化对象，即使它也是java的引用数据类型，可以定义变量。但是抽象类的引用可以指向子类的对象。

e.普通类中可以定义的成员和方法，都可以在抽象类中定义，因为子类可以调用这些成员和方法。

f.应用场景：①抽象类作为父类，描述类与类之间的关系；②抽象类中可以定义抽象方法，约束所有的子类都必须重写这个抽象方法。

g.小例子，AngryBird:

/*弹弓有一个弹射的方法将小鸟弹射出去，之后小鸟使用自己飞行的方法飞向小猪。
小鸟分为三类：红色小鸟，正常飞行；蓝色小鸟，一分为三；黄色小鸟，加速飞行
*/
public abstract class Bird {
    public abstract void birdFly();               //定义一个抽象类，抽象方法
}

public class RedBird extends Bird {             //继承
    public  void birdFly(){
        System.out.println("红火：正常飞行");           //重写抽象方法
    }
}

public class BlueBird extends Bird{
    public void birdFly(){
        System.out.println("蓝冰：一分为三飞行");       //重写抽象方法
    }
}

public class YellowBird extends Bird{
    public void birdFly(){
        System.out.println("黄风：加速飞行");         //重写抽象方法
}

public class Slingshot {
    public void shot(Bird bird){                
     bird.birdFly();                        //不能使用Bird.birdFly()，这里是父类引用调用被重写的方法
    }
}

public class Demo {
    public static void main(String[]args){
        Slingshot slingshot=new Slingshot();
        RedBird redBird=new RedBird() ;
        BlueBird blueBird=new BlueBird();
        YellowBird yellowBird=new YellowBird();
        slingshot.shot(redBird);                 
        slingshot.shot(blueBird);
        slingshot.shot(yellowBird);                //父类引用指向子类对象
    }
}

从例子看以看出，多态必须满足四个条件，缺一不可。

明天计划的事情： 

把接口的内容看掉，看一下类包和内部类，然后就开始看task17需要的知识点
遇到的问题： 

对于接口还是有点云里雾里，明天仔细研究下
收获：

对继承和多态有了更深的了解，现在对于类的三大特征总算可以有清晰的认识了

大概了解了final关键字，转接，抽象类的特性

对于昨天Maven的操作目的和操作方法有了更深的认识，果然如师兄所说，先做一遍，认识自然比单纯看要深得多。