发表于: 2018-03-06 23:21:58

2 694


今天完成的事情:

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的操作目的和操作方法有了更深的认识,果然如师兄所说,先做一遍,认识自然比单纯看要深得多。



返回列表 返回列表
评论

    分享到