发表于: 2018-03-06 23:21:58
2 692
今天完成的事情:
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的操作目的和操作方法有了更深的认识,果然如师兄所说,先做一遍,认识自然比单纯看要深得多。
评论