黑马程序员java培训就业班笔记：day05总结（共7篇）
篇1：黑马程序员java培训就业班笔记：day05总结
Day06总结： 上午
1、二维数组 格式：
Int[][] arr=new int[2][3];[2]代表1维数组的个数； [3]代表1维数组有三个元素； 内存图：
分析：
通过对内存图分布可知，首先在栈内存中加载main函数，开辟空间，定义一个变量arr，在堆内存中通过New创建一个数组实体int[2]，并分配其地址值为0x0045,数组元素值进行默认初始化为Null;然后把地址值赋值给栈内存中的arr.在堆内存中开辟两块空间，分别用来存放二维数组中的数组元素，分配其地址值分别为0x0056、0x0089,然后对将地址值传给二维数组中的元素，所以说对内存中二维数组存储的是一维数组的地址值。最后变量通过二维数组的地址0x0045指向二维数组。
注意：二维数组中必须指定长度、以及实体没有对二维数组进行初始化时默认为null;
2、对二维数组的遍历（大圈套小圈思想）For(int x=0;x
3、面向对象的理解：
特点：
1、面向对象就是更符合人们思考习惯的一种思想。
2、从面向过程的执行者，转变成了面向对象的指挥者
3、面向对象将复杂的事情简单化了。
其实面向对象是一种思想，是面向过程而言，将复杂的事情变的更简单了。通过把大象放到冰箱里这个列子来理解面向对象的概念
面向过程：把冰箱门打开、存储大象、关闭冰箱；强调的过程注重行为； 面向对象：冰箱.打开、冰箱.存储、冰箱.关闭；强调的是冰箱这个对象。
面试题：你怎么理解面向对象？
首先说面向对象的特点：它是一种思想，它让复杂的问题简单化，它把执行者变成了指挥者。
然后举例子来说明，最牛的就是结合实际场景来说：其实面试官你就是在用面向对象的思想在思考问题，为什么这么说？因为公司业务蒸蒸日上，需要招更多的人来完成项目，所以才在这里招聘人员，你需要找一些具备专业编程经验的人，来帮公司完成工作，那么我就是那个对象，因为我具备专业编程能力，你就是那个指挥者，指挥我来做事，至于我怎么去完成编程任务，你是不需要去知道，你只要结果了就可以了，这其实就是把你之前的工作简化了，你不必再事必躬亲了。这就是面向对象思想的体现。
同时可以结合去饭店吃饭，在家做事等等列子来说明面向对象的思想。
扩展：OOP:面向对象编程。
OOA面向对象分析。
OOD:面向设计。还有面向接口、面向框架、面向对象的语言：C++、JAVA、C#
4、在实现功能，先找java当中是不是提供好了相关的对象，没有对象自己造一个对象。比如说公司招聘人员找不到人的时，这时公司就需要自己在公司内部培养人，也就是自己造对象。
5、类和对象关系：
a)类到底是什么？
类就是对现实生活中事物的描述，描述中包含了该类事物的共性内容。Class Car(){ Int num;String color;Void run(){} } 在类中定义的变量和函数都称为类中的成员。成员：
成员变量---属性 成员函数---行为
b)什么是对象？
对象就是该类事物实实在在存在的个体。
Eg：现实生活中的对象：张
三、李四
想要描述：提取对象中的共性内容，对具体的抽象。
描述时：这些对象的共性有姓名年龄性别学习java的功能。对象也可以理解为其实就是个容器，用来存储更多的数据，存储的都是每一个对象特有的数据，而类就是这些数据所属的属性。
用java语言来描述一个小汽车
描述事物：无非就是描述事物的属性和行为 属性：轮胎数、颜色 行为：运行 Eg: Class Car { String color=“red”;Int num=4;Run(){ System.out.println(color+“"+num);} } Class CarDemo { Public static void main(String[] args){ Car c=new Car();C.color=”bule“;C.num=5;C.run();m
Car c1=new Car();C1.num=8;C1.color=”green“;C1.run();} } 重点：分析上述代码在内存中的分布：
复习的时候写内存分析：
6、成员变量和局部变量的区别：
1、源代码中定义位置不同：
成员变量：定义在类中，在整个类中有效。局部变量：定义在函数中，在局部范围内有效。简单一句话：作用范围不一样，成员变量作用于整个类中，局部变量作用于函数中，或者语句中。
2、在内存中的位置和事件不同：
生命周期不同：
成员变量：随着对象的创建的而出现在堆内存中，随着对象被回收而消失。
局部变量：随着变量所属局部区域的运行，而出现在栈内存中，随着所属区域运行结束而释放。
3、变量使用的初始化：
成员变量：因为堆内存中都有默认初始化值，对于引用型变量默认值就是null;局部变量：因为在栈内存中都没有默认初始化值，必须手动初始化后才可以参与运算。
7、匿名对象：
即没有名字的对象，简化书写用的。基本使用：
1、当对对象的方法只调用一次时，可以用匿名对象来完成
这样写比较简化，如果对一个对象进行这个成员的调用，必须给这个对象起个名字
2、可以将匿名对象作为实际参数进行传递。一旦对对对进行多个成员操作时。必须要对对象起个名字。
Eg: Main(){ Show(new Car（）)} Public static void show(Car c)
{ C.num=3； C.color=”back";C.run();}
8、面向对象三个特征：
封装：
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式，凡是面向对象必须有封装性。
特点： 将变化隔离 便于使用 提高复用性 提高安全性
原则：
1、将不需要对外提供的内容都隐藏起来。
2、把属性都隐藏，提供公共方法对其访问。在代码中的体现：
1、将成员变量都私有化，并通过共有的方法对其进行访问，这两个方法是:setXxxgetXxx
2、只要不准备对外提供的全部都封装起来，3、私有仅仅是封装的一种表现形式，函数是最小的封装体。方法需要私有吗？
Public static void selectSort(){ Swap();} Private void swap()//此处私有是因为位置置换不用提供给用户。{ } 代码实现： Class Person { Private int age;//为了不让其他程序直接访问age属性，避免错误的数据，可以使用一个关键字来完成private私有，它是一个权限修饰符。
Public void setAge()//对外提供函数是可以控制你输入的参数。//一个成员变量通常对应的两个方法、{ If(a>130||a<0){ Age=a;
Speak();} Else System.out.println();} Public void getAge(){ Return age;}
Void speak(){ Sop();} } Class PersonDemo { Public static void main(String[] args){ Person p=new Person();P.age=-20;//错误数据是因为对象直接访问age属性造成的。P.speak();} } 总结：之所以对外提供访问方式，就是因为可以在访问方式中加入逻辑判断等语句 对访问的数据进行操作，提高代码的健壮性。凡是set开头的返回值类型是void，get开头的跟它的返回值类型一致。
篇2：黑马程序员java培训就业班笔记：day05总结
1、final关键字：
Eg:代码实现：
Class Fu { Final void method(){
//code...访问低层代码
} } Class Zi extends Fu { Void method()
{
Sop(“haha”);} } 以上代码体现出继承的弊端，因为父类的method的方法访问了系统的低层代码。当子类对其覆写，就不会去访问父类的meth的方法，直接用自己的method这样就出现了代码的不严谨性，所以此时需要用final关键字进行修饰。注意为什么不把类加final修饰，因为可能该类中会出现很多功能。有些是不需要被覆写的。有些是被调用的。所以只能根据自己所需对相应的成员进行修饰。
2、Final的特点：
1、final是一个修饰符，可以修饰类、方法、变量(成员变量、局部变量)
2、Final修饰的类不可以被继承。
3、Final修饰的方法不可以被覆盖。
4、Final修饰的变量是一个常量，只能被赋值一次。是为了增强阅读性，只要数据是固定的，就将这个数据用一个名称来表示，并用final修饰。常量名称都是大写字母，多个单词组成时用下划线来分隔。
代码体现：
Eg:
Class Zi { Static final int num=90;//必须对变量进行初始化，不知道要最终化哪个值，所以必须对它进行初始化。加静态也是一样的，同样的道理，并且被初始化，此时静态和final没有必然的联系。当变量被final修饰时，说明变量已经是一个常量值，此时不能被修饰，可以用static来修饰。
Public stati double PI=3.14;Void method(){
Final int x=4;
X=8;
Sop(num);//既然是在操作一个固定的值。为什么不把4直接写在此处，如果这样做的的话，阅读性极差，你根本就不知道它所代表什么？为了增强阅读性，此时数据是不变化的，所以我们需要给它起个名字，并且用final来修饰。这样的话它也是固定的不变的。
注意：被final修饰的数值只能被覆写一次，并且修饰的常量名全部大写，多个单词组成时用下划线进行分隔。Eg:final int PERSON_AGE=4;} }
3、抽象类：
特点：
1、没有方法体的方法，称为抽象方法，必须存放在抽象方法类中，抽象方法和抽象类必须用abstract关键字来修饰，2、抽象类不可以被实例化，为什么？因为调用抽象方法没有意义？为什么？因为它连方法体都不存在？
3、抽象类必须由其子类将抽象类中的抽象方法都覆盖后，其子类才可以被实例化，否则该子类还是抽象类。Eg: Abstract class Demo { Abstract void show();} Class SubDemo extends Demo
Void show(){} //此时把父类中抽象方法覆盖，此时才能被实例化。} 比如水果，它就是抽象的，不具体它包含各种各样的水果，每种水果有它自己的体现。
抽象类涉及的问题？
1、抽象类中是否可以定义非抽象的方法？
可以 首先抽象类是一个类，类是用来描述事物，只不过描述事物过程中有些信息不具体，抽象类和一般类异同点：
相同：抽象类和一般类都用于描述事物，都可以定义成员。不同：抽象类中可以定义抽象成员函数，（抽象要么修饰类要么修饰函数）而一般类不可以。
抽象类不可以实例化，一般类可以实例化。
2、抽象类中是否有构造函数？
有，而且抽象类虽然自身不可以被实例化，但是其子类覆盖了所有的抽象方法后，是可以实例化的。所以抽象类的构造函数是用于给其子类对象进行实例化。
3、抽象类通常都是一个父类？
是、因为需要子类去覆盖父类中的抽象方法。代码体现：
Abstract class Demo{ Abstract voif show1();Abstract void show2();} Abstract class SubDemo extends Demo { Void show1();} Class Test extends SubDmeo { Void show2();}
4、抽象类中可不可以不定义抽象方法？
可以；看上去没有什么意义，其实有点意义，就是不让这个类创建对象，为什么不让创建？ 代码体现：
interface InterTest//这是一个测试接口，有4种测试方式。
{ void test1();void test2();void test3();void test4();
} abstract class InterTestImpl implements InterTest//用这个类进行所有的空实现。但是创建对象是毫无意义的。所以用抽象。
{
public void test1(){}
public void test2(){}
public void test3(){}
public void test4(){} }
class Test2 extends InterTestImpl
{ public void test2(){}
}
class Test3 extends InterTestImpl
{ public void test3(){}
}
/*
class InterTestImpl implements InterTest
{
public void test2()//
{
sop(“testimpl test2”);
}
public void test1(){}//这样做实现太麻烦。代码重复。如何改进？
public void test3(){}
public void test4(){}
}
*/
5、抽象关键字 不可以和那些关键字共存？
Final：修饰了类是一个最终类，不可以被继承，然后abstract修饰的类必须是父类，需要被继承、冲突、非法的修饰符组合，abstract 和final Static:抽象方法被static修饰，就具备了可以被类名直接调用的的特点，但是抽象方法被调用没有意思。
Priavte：因为抽象方法被私有，无法被覆盖。
代码体现： 雇员实例：
需求：公司中程序员有姓名、工号、薪水、工作内容。
项目经理除了姓名、工号、薪水、还有奖金、工作内容
进行数据建模
做问题领域的分析就是找出问题领域的对象。
分析: 在这个问题领域中有两个对象： 程序员：
属性：姓名，工号，薪水
行为：工作内容 项目经理：
属性：姓名、工号、薪水、奖金
行为：工作内容。
这时候不能用项目经理去继承程序员。因为职能不同，但是有共性，只能抽取。
就有了员工：
属性：姓名，工号，薪水
行为：工作内容
*/ abstract class Employee
{ private String name;private String id;private double pay;Employee(String name,String id,double pay){
this.name=name;
this.id=id;
this.pay=pay;} public abstract void work();//工作内容是无法知道的。} class Programmer extends Employee { Programmer(String name,String id,double pay){
super(name,id,pay);} public void work(){
System.out.println(“code”);}
}
class Manager extends Employee { private double bonus;Manager(String name,String id,double pay){
super(name,id,pay);
this.bonus=bonus;} public void work(){
System.out.println(“manage”);} }
4、接口：
格式：interface{} 表现特点：
1、里面的方法都是抽象的。
2、接口中的成员都有固定的修饰符，最常见的成员：全局常量抽象方法。只是最常见，不代表只有它们没有其他的，全局常量，共有的不需要对象，直接用接口调用的，不可变的。
表现形式：Public static final
抽象方法：public abstract
3、接口的成员都是public的。
4、接口是不可以创建对象的。就相当于是抽象的特殊表达形式。（但是有区别和抽象类）
5、类与类之间是继承关系，类与接口之间是实现关系。
6、接口的出现可以多实现，避免了单继承的局限性。
7、一个类在继承一个类的同时，还可以实现多个接口、8、接口与接口之间是继承关系，而且可以多继承，以为接口的方法都没有主体。思想特点：
1、对外暴露的规则。
外设要介入计算机中，因为计算机外面提供了接口，这就是规则。
2、程序的功能扩展
3、降低了耦合性
4、用来多实现
结合电脑主板的思想进行阐述，它是个规则。对外提供的规则 它提高了我们功能的扩展性，降低了耦合性。主板和声卡：主板使用规则，声卡实现规则。
与抽象类的区别：抽象类有单继承的局限性，接口没有
5、java对多继承记住改良，以多现实接口的方式来体现。差别：多继承因为父类中有相功能时，会造成不确定性。为什么可以实现多实现？
因为继承中父类的方法有方法体？这才是造成不确定性的根本原因，而此处是没有方法体的。
代码体现：
interface A {
//int show();//这样是不可以的。无法覆盖。
void show();} interface B {
// void method();
void show();//当有重复的方法时。但是此时子类复写它是可以的，为什么？
//因为继承中父类的方法有方法体。这才是造成不确定性的根本原
因。而
//此处是没有方法体的。
} class C extends D implements A,B//多实现。此时c必须覆盖两个方法
{
public void show(){}
//public void method(){}
} //一个类在继承一个的类的时候还可实现多实现
class D
{
public void function();} //接口之间是可以继承，而且支持多继承。
interface InterA {
void showA();} interface InterB {
void showB();} interface InterC extends InterA,InterB//为什么此处可以实现多继承，因为方法没有主体。
{
void showC();}
class InterfaceDemo2
{
public static void main(String[] args)
{
C c=new C();
c.show();
System.out.println(“Hello World!”);
}
}
6、抽象类和接口之间的区别：
共性：它们都是不断抽取出来的抽象非概念
区别：
1、抽象类只能被单继承、接口可以被多实现，避免了单继承的局限性。
2、抽象类中可以定义抽象方法，和非抽象方法，它可以用于定义体系的基本共性的内容。接口中只能定义抽象方法，它主要用于对象的功能的扩展。
3、抽象类是继承关系，是is a关系，接口是实现关系是like a关系。
4、抽象类中的成员修饰符都是自定义的，接口中的修饰符都是固定的。记住：不要把接口狭义的理解为interface,应该理解广义些，就是对外提供的规则，凡是对外暴露的都可以是接口。
实现代码：
1、abstract class 犬
{ public abstract void 吃饭();
public abstract void 吼叫();
}
interface 搜爆
{ public void 搜爆();
}
class 搜爆犬 extends 犬 implements 搜爆//这是即具备了犬的基本特性，又具备了搜爆功能。
{ public void 搜爆(){} public void 吃饭(){}
public void 吼叫(){}
}
class 搜爆猫 extends 猫 implements 搜爆
{ public void 搜爆(){}
}
记住： 类里面都是定义的一些基础内容，接口里面都是定义一些特性内容，这样的方便了对其进行扩展。
//抽烟的学生，抽烟是额外功能。
2、abstract class Student
{ abstract void study();
}
interface Smoking
{ void smoke();
}
class SomkeStudent extends Student implements Smoking
{ public void study(){}
public void smoke(){}
}
//烟民。学生烟民 问题领域不同，对象的属性和行为也不同。
abstract class Somker
{
abstract void smoke();
}
interface Study
{ void study();
}
class StudentSmoker extends Smoker implements Study
{ public void smoke(){} public void study(){}
}
7、多态：重点掌握
定义：某一类事物的多种存在形态。代码实现：
class 动物
{}
class 猫 extends 动物
{
}
猫 x=new 猫();
动物 y=new 猫();//父类的引用变量指向了其子类的对象。
多态在代码中的体现，父类或者接口的引用指向了自己的子类对象。
实现代码：
class Animal
{ abstract void eat();
}
class Dog extends Animal
{ void eat(){
sop(“啃骨头”);} void lookHome()
{
sop(“看家”);}
}
class Cat extends Animal
{ void eat(){
sop(“吃鱼”);} void catchMouse(){
sop(“抓老鼠”);}
}
class Pig extends Animal
{ void eat(){
sop(“猪饲料”);} void gongdi(){
sop(“拱地”);}
} class DuoTaiDemo { public static void main(String[] args){
//Cat c=new Cat();
//c.eat();
//Cat c1=new Cat();
//c1.eat();
//method(c);
//method(c1);
重要知识点：----开发都用！
Animal a=new Cat();//此处猫对象类型自动向上提升---向上转型，当指向使用体系基本功能时，可以向上转型操作。
为什么体现多态性？
首先猫是一个实体，是一个猫类型，因为有了继承，是动物中的一种，把这个实体称之为动物也可以，所以它具备了两种形态，猫和动物。这便是体现了多态性。
//一旦向上转型，猫就不是猫了，已经是动物类型了。
a.catchMouse();//编译失败。
但是现在想执行猫的抓老鼠的功能怎么办？
向下转型：
Cat c=(Cat)a;//向下转型。当使用子类对象中的特有内容时，才做向下转型。
c.eat();
c.catchMouse();//此时是可以实现猫的抓老鼠的功能的。
总结：在多态转型中，至始至终只有子类对象做着类型的变化。
method(new Cat());
} public static void method(Animal a)//Animal a=new Cat();{
重点知识点：instanceof
if(a instanceof Cat)//对象instanceof 类型 判断具体对象是否是指定的类型。
{
Cat c=(Cat)a;//编译通过，但是不能运行，此时类型转换异常classCastException;
//此时为了程序的严谨性，需要对传入的的对象进行判断。
c.catchMouse();
}
else if(a instanceof Dog)
{
Dog d=(Dog)a;
d.lookHome();
}
a.eat();
总结：
instanceof是一个关键字，用于判断对象的类型。什么时候用？
当进行向下转型时，先判断该对象是否符合被转成的子类型。
} }
8、重点理解：
1、多态的好处：提高了代码的扩展性，有了多态，前期设计好的内容可以使用后期出现的子类内容，对于指挥对象做事情这件事情，如果对象很多，指挥起来很麻烦，抽取对象的共性类型，对该类型的事物进行指挥就会变的很简单。
2、多态的前提：
1、必须要有关系：继承、实现。
2、必须有覆盖的操作。
篇3：黑马程序员java培训就业班笔记：day05总结
Padding:一个数字，指的是四个方向是一样的（上右下左）
Padding的四个属性：
Padding-top(上内边距),padding-right(右内边距),padding-bottom(下内边距),padding-left(左内边距)Padding:当padding后有两个数字时即Padding:10px 20px;指的是上下内边距为10px,左右内边距为20px 注意：两个数字之间有空格。
Padding：当padding后有三个数字时即Padding:10px 20px 30px;指的是上边距10px,下边距的填充为30px,左右边距为20px;Padding:当padding后有四个数字时即padding:10px 20px 30px 40px;按着顺时针方向。(上右下左)注释：不允许使用负值。代码：
抓住眼前的人和事，不要再去为那遥远的虚无缥缈耗费心思，做你该做的事，不要为别人，与自己没关系的事，费劲自己的心思，不要活在过去里，无论你有任何的伤痛，回忆只会带给自己无穷无尽的苦恼，走出痛苦，活在当下，人生路很长，我要走好。
篇4：黑马程序员java培训就业班笔记：day05总结
PHP函数 1.概念
将一段常用的功能代码，进行封装，然后起个名字，叫”函数” 使用函数，可以减少我们的工作量。对于后期的项目维护，十分方便。2.函数定义格式
Function functionName(形参1，形参2，形参3......){
函数的功能代码
[return 参数r] } 函数语法格式说明：
Function是系统关键字，不分大小写。
functionName是自定义的函数名称。函数名的命名规则与变量一样，只是不加$符号。
()定义函数时的参数，该参数又称为”形参”。
形式参数：主要用来接收调用函数者，传递过来的数据。
形参可以是多个，多个形参之间用逗号隔开，也可以没有形参
形参其实就是一个变量的名称，主要用来临时存储数据的。{}是函数的功能代码。Return语句：
向谁返回内容？谁调用了该函数，就向谁返回。
返回什么内容？该内容的类型不限制，可以是任何数据类型
黑马程序员济南中心 编著
Return语句，一旦执行，函数将中止。也就是return语句之后的函数代码不再执行。
Return 语句返回一个值，并退出函数。
3.函数调用
函数定义是不会自动执行的。函数必须要经过调用，才能看到结果 调用函数和定义函数不分顺序。4.函数参数
a)形式参数(形参)：形参主要用来接收调用函数传递过来的数据。
i.形参一般是变量，不能是具体的值
ii.形参只能在函数内部使用
b)实际参数(实参)：向定义函数传递的数据
i.实参可以是具体值，也可以是一个变量
c)形参和实参的个数，一般情况下必须一致 Function showInfo($a){ Echo “OK”;} $a = 100;showInfo($a);函数参数传递 1.值传递(拷贝传值)将一个变量的值,”拷贝”一份，传给形参
黑马程序员济南中心 编著
在函数内部，对形参进行了修改，而函数外的这个变量不会改变 函数内的形参，与函数外的实参，是相互独立的，没有任何联系的
在PHP中，默认”值传递”的有：字符型、整型、浮点型、布尔型、数组、NULL
2.引用传递
将一个变量的地址传给形参，即形参与变量指向的是”同一物”.变量和参数之间是相互联系，修改一个，另一个会跟着变。
参数在使用引用传递时，需要在”形参”前加一个”&”符号。”实参”前不能添加。
默认引用传地址：资源和对象
黑马程序员济南中心 编著
3.默认参数
PHP支持默认参数。
当实参格式少于形参个数时，那么少的那个实参可以用末日的形参来代替
匿名函数
1.概念
没有名字的函数就是匿名函数，它不能单独定义也不能单独调用 匿名函数一般用来给其他变量赋值的。
黑马程序员济南中心 编著
2.匿名函数的两种用法
i.将匿名函数当成一个数据，赋给其他变量
ii.将匿名函数作为函数的参数来使用
变量作用域
变量作用域：就是变量生效的范围
在PHP中三种变量作用域：全局变量、局部变量、超全局变量。1.全局变量
全局变量：在函数外部定义的变量，称为”全局变量”。
黑马程序员济南中心 编著
全局变量，在网页执行完毕，就消失了。在JS中，全局变量，可以直接在函数内部来使用 在PHP中，全局变量不能直接在函数内部使用 2.局部变量
局部变量：在函数内部定义的变量，称为”局部变量”。局部变量，只能在函数内部来使用 局部变量，在函数执行完毕后就消失了。3.在局部作用域中访问全局变量---global关键字
Global关键字，只能在函数内部来使用
不能在使用global关键字时，直接给变量赋值。只能是先声明为全局，再赋值。
$GLOBALS超全局数组
“超全局数组变量”可以在网页的任何地方使用，包括函数内部和函数外部。$GLOBALS超全局数组中包含的内容有：$_GET、$_POST、$_COOKIE、$_FILES
篇5：黑马程序员java培训就业班笔记：day05总结
第1章 框架概述
什么是框架，为什么使用框架，框架优点
框架（framework）是一个基本概念上的结构，用于去解决或者处理复杂的问题
框架，即framework。其实就是某种应用的半成品，就是一组组件，供你选用完成你自己的系统。简单说就是使用别人搭好的舞台，你来做表演。框架是在特定的领域内解决问题。优点
重用代码大大增加，软件生产效率和质量也得到了提高
使用框架开发，它提供统一的标准，大大降低了我们的后期维护。学习框架重点:了解框架做了什么，我们要在这个基础上在做什么事情。
第2章 java开发中常用框架
SSH
(SSM SSI)SSH struts2 spring hibernate SSM(SSI)springmvc spring mybatis(ibatis)
SSH 它是企业开发中比较主流的一套架构。SSH框架在开发中所处的位置:
黑马程序员郑州中心 编著
第3章 Struts2框架介绍
什么是struts2框架，学习struts2框架的核心。
Struts2是一个基于MVC设计模式的Web应用框架，它本质上相当于一个servlet，在MVC设计模式中，Struts2作为控制器(Controller)来建立模型与视图的数据交互
Struts2=struts1+webwork
问题:struts2是一个mvc框架，它的mvc是什么?
javaweb开发中的mvc,是在jsp的model2模式中提过 Model------javabean View--------jsp Controller----servlet
黑马程序员郑州中心 编著
核心点: 1.拦截器 interceptor 2.Action 3.ognl与valueStack
在现在开发中与struts2比较类似的框架有哪些? Struts1 webwork springmvc jsf
Struts2框架流程
黑马程序员郑州中心 编著
第4章 今天内容介绍与重点
今天内容：
一个简单的登录案例
在这个案例中，我们要使用struts2框架怎样解决
重点: 1.struts2框架如何完成原来由servlet完成的工作。2.Struts2框架如何完成请求参数的封装处理 3.Struts2框架如何完成页面跳转。
黑马程序员郑州中心 编著
第5章 简单登录案例原型
需要三个jsp页面
login.jsp
success.jsp failer.jsp 还需要一个servlet
LoginServlet 主要完成的是业务逻辑操作。
login.jsp
LoginServlet
黑马程序员郑州中心 编著
第6章 Struts2框架来完成登录操作
6.1 问题:为什么使用struts2框架？
Struts2框架它是一个在web中应用的mvc框架。我们使用strtus2框架来完成web开发有什么优势？
6.2 问题：怎样使用strtuts2框架
首先要上网下载它的jar包。步骤: 1.导入相关的jar文件
2.需要在web.xml文件中配置一个Filter（只有配置了它才可以使用struts2框架）
黑马程序员郑州中心 编著
3.struts.xml配置
4.创建Action来完成逻辑操作
6.3 快速入门
我们使用的是struts2 2.3.24版本
我们使用strtus2框架不是直接将它的lib包下的所有的jar文件copy到项目中，而是使用其中的一部分。
我们可以参考它的示例代码：
1.导入13个jar包
2.需要在web.xml文件中配置StrutsPrepareAndExecuteFilter 3.创建一个struts.xml文件,它的位置是可以放置在src下。
黑马程序员郑州中心 编著
6.3.1 代码实现 6.3.1.1 jsp页面
6.3.1.2 Action
6.3.1.3 struts.xml文件配置
6.3.2 流程分析
黑马程序员郑州中心 编著
6.4 使用struts2完成简单登录操作
1.login.jsp页面不变动
2.创建一个LoginAction来完成逻辑操作 3.在struts.xml文件中完成配置操作
问题1:在LoginAction中如何得到username与password 可以直接在Action类中提供成员属性，并为其提供get/set方法。就可以得到请求参数
问题2:如果实现路径跳转？
1.我们可以给action中的方法添加一个String返回值
2.在struts.xml配置文件中，在其对应的action配置上通过
黑马程序员郑州中心 编著
第7章 Struts2框架执行流程
7.1 Struts2源码导入
对于struts2框架它的源代码我们主要使用三部分 1.struts2核心部分源代码
org.apache.struts2xx
srccoresrcmainjava
2.struts2的xwork核心部分源代码
srcxwork-coresrcmainjavacomopensymphonyxwork2 3.struts2的插件的源代码
srcplugins 7.2 关于struts.xml配置文件中提示问题
第一步
在eclipse的window下首选面中查找xml catalog 第二步
Location:配置本地的dtd文件路径 key type:选择URI
黑马程序员郑州中心 编著
Key: http://struts.apache.org/dtds/struts-2.3.dtd
注意版本要对应，如果你可以上网，那么会自动缓存dtd,具有提示功能。
7.3 执行流程介绍
1.当通过浏览器发送一个请求
2.会被StrutsPrepareAndExecuteFilter拦截
3.会调用strtus2框架默认的拦截器(interceptor)完成部分功能 4.在执行Action中操作
5.根据Action中方法的执行结果来选择来跳转页面Resutl视图
一般管StrutsPrepareAndExecuteFilter 叫做前端控制器(核心控制器)，只有配置了这个filter我们的strtus2框架才能使用。
黑马程序员郑州中心 编著
Strtus2的默认拦截器(interceptor)它们是在struts-default.xml文件中配置 注意:这上xml文件是在strtus-core.jar包中。默认的拦截器是在defaultStack中定义的。
第8章 Struts2配置详解
8.1 Struts2配置文件加载顺序
第一个加载的是default.properties文件
位置:strtus2-core.jar包
org.apache.struts2包下 作用:主要是声明了struts2框架的常量
第二个加载的是一批配置文件
Strtus-default.xml 位置:struts2-corl.jar
作用:声明了interceptor result bean Strtus-plugin.xml 位置:在strtus2的插件包中 作用:主要用于插件的配置声明 Strtus.xml
黑马程序员郑州中心 编著
位置:在我们自己的工程中
作用:用于我们自己工程使用strtus2框架的配置 第三个加载的是自定义的strtus.properties 位置:都是在自己工程的src下 作用:定制常量 第四自定义配置提供
第五加载的是web.xml配置文件
主要是加载strtus2框架在web.xml文件中的相关配置.第六 bean相关配置
重点掌握: 1.Default.properties 2.Struts-default.xml 3.Struts-plugin.xml 4.Strtus.xml 5.web.xml
8.2 struts.xml文件配置介绍
8.2.1 package配置
1.name属性
作用:定义一个包的名称，它必须唯一。
黑马程序员郑州中心 编著
2.namespace属性 作用:主要是与action标签的name属性联合使用来确定一个action 的访问路径
3.extends属性 作用:指定继承自哪个包。一般值是strtus-default strtus-default包是在strtus-default.xml文件中声明的。
4.abstruct属性 它代表当前包是一个抽象的，主要是用于被继承
8.2.2 action配置
1.name属性 作用:主要是与package的namespace联合使用来确定一个action的访问路 径
2.class属性
作用:用于指示当前的action类
3.method属性
作用:用于指示当前的action类中的哪个方法执行
8.2.3 result配置
它主要是用于指示结果视图
1.name属性 作用是与action类的method方法的返回值进行匹配，来确定跳转路径 2.type属性 作用是用于指定跳转方式
8.2.4 扩展
关于action配置中的class与method的默认值以及result中的name与type 默认值问题
原因:strtus-default.xml文件中配置
黑马程序员郑州中心 编著
它的作用就是当一个请求来时，如果查找不到指定的class及对应的method就会执行 ActionSupport类中的execute方法。
在这个类的execute方法中默认返回的是”success”
也就是说，result的name属性默认值是success,默认的跳转方式是请求转发 dispatcher
8.3 常量配置
default.properties文件中定义了struts2框架常用常量.问题:我们怎样可以定义常量
1.可以在src下创建一个strtus.properties配置文件 2.可以在web.xml文件中配置
3.可以直接在strtus.xml文件中定义常量(推荐)
注意:后加载的配置文件中的常量会将先加载的常量覆盖
第9章 Struts2的Action详解
Struts2中的action，主要是完成业务逻辑操作。Action替代在servlet中完成的作用。
黑马程序员郑州中心 编著
Action的学习主要有两点
1.如何创建一个struts2的action 2.如果访问一个struts2的action
1． Action类创建方式(三种)1.创建一个pojo类
Pojo(plani Ordinary java object)简单的java对象 Pojo类就是没有实现任何接口没有继承任何类 优点:无耦合
缺点:所有的功能都要自己完成
2.创建一个类实现一个Action接口
com.opensymphony.xwork2.Action
在Action接口中定义了五个常量，一个execute方法 五个常量:它们是默认的五个结果视图
INPUT: 它是struts2框架中interceptor中发现问题后会访问的一个视图 LOGIN:它是一个登录视图，可以在权限操作中使用
黑马程序员郑州中心 编著
NONE:它代表的是null,什么都不做（也不会做跳转操作）SUCCESS:这是一个成功视图 优点：耦合度低
缺点:还是需要自己来完成功能
3.创建一个类继承ActionSupport类
com.opensymphony.xwork2.ActionSupport ActionSupport类也实现了Action接口。我们在开发中一般会使用这种方案: 优点:具有丰富的功能，例如
表单校验 错误信息设置
国际化 缺点:耦合度高
9.1 action的访问方式
1.直接通过标签来配置，通过method来指定访问的方法，如果method没有，默认访问的是execute方法。
2.简化的action访问方式，可以使用*通配符来访问。
这种方式的缺点:不建议使用过多的*号，它带来程序阅读障碍，不便于理解 使用*来简化操作方案，它对名称规范必须进行一个统一。
黑马程序员郑州中心 编著
9.2 扩展--动态方法调用
这是strtus2提供的动态方法调用。
注意:对于strtus2的动态方法调用，要想使用我们必须配置一个常量来开启动态方法调用
这代表动态方法调用没有开启
黑马程序员郑州中心 编著
个人不建议使用动态方法调用
第10章 Struts2框架封装数据
主要解决的问题:是在action中如果获取请求参数
主要有两种方式: 1.属性驱动
a.直接在action类中提供与请求参数匹配属性，提供get/set方法
b.在action类中创始一个javaBean,对其提供get/set，在请求时页面上要进行修改，例如 user.username user.password ,要使用ognl表达式
以上两种方式的优缺点: 第一种比较简单，在实际操作我们需要将action的属性在赋值给模型(javaBean)去操作 第二种:不需要在直接将值给javaBean过程，因为直接将数据封装到了中。它要求在页面上必须使用ognl表达式，就存在页面不通用问题。javaBean
2.模型驱动
步骤: 1.让Action类要实现一个指定接口ModelDriven 2.实例化模型对象(就是要new出来javaBean)3.重写getModel方法将实例化的模型返回。
黑马程序员郑州中心 编著
对于模型驱动它与属性驱动对比，在实际开发中使用比较多，模型驱动缺点，它只能对
一个模型数据进行封装。
第11章 总结
今天主要内容是围绕着简单的登录案例来讲解: 1.关于strtus2框架的环境搭建 2.关于strtus2框架配置 3.关于strtus2框架请求参数封装 4.关于strtus2框架的路径跳转
关于action访问的配置
黑马程序员郑州中心 编著
namespace=””
extends=””>
class=””
method=””>
关于路径跳转问题: 是通过
默认值是dispatcher 它代表的是请求转发。针对于jsp页面 redirect 它代表的是重定向
针对于jsp页面
chain 它类似于请示转发，只不过它是针对于action跳转.redirectAction 它类似于重定向
针对于action 关于路径跳转的配置
可以直接在
下创建全局的result
黑马程序员郑州中心 编著
篇6：黑马程序员java培训就业班笔记：day05总结
关键字
今天我来为大家讲解一下PHP类中的一些关键字： parent和self关键字 parent：
用在一个类的一个方法中；
代表这个类的“父类”——注意，是代表一个类，不是类的对象；
但：实际应用中，常常会看起来“代表”这个类的父类对象——因为用的时候，是使用了父类的对象来调用某个方法而产生了所谓的对象传递； [PHP] 纯文本查看 复制代码 ? 01
黑马程序员济南中心 编著 1;//声明静态属12 性 13 } 14 15 class B extends A{ static function f1(){ echo “父类的静态属性s1:”.parent::$s1;echo “父类的常量PI:”.parent::PI;} } B::f1();显示结果：
父类的静态属性s1:1
父类的常量PI:3.14
黑马程序员济南中心 编著
self：
用在一个类的一个方法中；
代表这个类“本身”——还是代表一个类，而不是类的对象； [PHP] 纯文本查看 复制代码 ? 01
黑马程序员济南中心 编著
己的常量PI:”.self::PI;} } B::f1();典型使用1：
在构造方法中，调用父类的构造方法，以完成对象的一些共同的数据初始化工作。[PHP] 纯文本查看 复制代码 ? 01
04 class Member{ 05 public $name;//声明一个变量 06 public $salary;//声明一个变量 07 //创建一个构造方法 08 function
09 __construct($name,$salary){ 10 $this->name = $name;//把实例11 化类时的实参传递给之前声明好的变量 12 $this->salary = $salary;//把实例13 化类时的实参传递给之前声明好的变量
黑马程序员济南中心 编著 } 15 } 16 class Teacher extends Member{ 17 public $edu;//声明一个变量 18 //创建一个构造方法 19 function __construct($name,$salary,$edu){ 21 //$this->name = $name;22 //$this->salary = $salary;23 //将上面两行的内容用下面一行类24 代替 //调用父类的构造方法，去完成一个26 共同属性数据的初始化 parent::__construct($name,$salar28 y);29 //把实例化类时的实参传递给之前声30 明好的变量
$this->edu = $edu;32 } 33 } 34 class Student extends Member{ 35 public $age;//声明一个变量
黑马程序员济南中心 编著
//创建一个构造方法 37 function
__construct($name,$salary,$age){ 39
//调用父类的构造方法，去完成一个41 共同属性数据的初始化
parent::__construct($name,$salary);//把实例化类时的实参传递给之前声明好的变量
$this->age = $age;} } $t1 = new Teacher(“老师”,1000,“大学”);echo “
”;var_dump($t1);echo “
”;$s1 = new Student(“学生”,100,18);var_dump($s1);
黑马程序员济南中心 编著
不知道大家对今天讲解的parent和self关键字学习的程度如何啊？如果有兴趣，欢迎来黑马程序员济南中心来详细了解PHP~
篇7：黑马程序员java培训就业班笔记：day05总结
之前写了“Java之debug总结一”,“Java之debug总结二”共总结了5种debug方式,现在简绍第6种,不足之处,敬请指正:(源码在文章末尾处)本文以chrome浏览器为例
六.前台debug 主要:debug js代码(1.jsp中嵌入的js代码 2.js文件中的js代码)第一步:首先创建一个web项目,需要有一个jsp页面和js,如下图:
第二步:在test.js,index.jsp中填充内容,如图示: index.jsp
黑马程序员济南中心 编著
test.js
第三步:把项目发布到tomcat服务器中,并启动tomcat服务器
第四步:在浏览器上访问index.jsp,使用“F12”打开chrome开发者工具,如下图:
黑马程序员济南中心 编著
选中“Source”,点击,出现如下界面
黑马程序员济南中心 编著
点击“[url=]encode测试[/url]”按钮进行测试
以上为外部js代码测试,测试过程中可以修改js的内容,“Ctrl+s”保存后,可以立马生效,断点会从第一行从新开始.黑马程序员济南中心 编著
内部js测试步骤类似于上面的步骤,只是在选择资源的时候不是选择“test.js”,而是选择“index”,选择后页面如下图:
测试步骤和外部js一样
比较外部js和内部js的区别: 外部js,可以进行动态的修改, 修改之后立马生效,并且可以立马进行测试.内部js,不可以动态修改,用起来有点不方便
以上以我用过的所有debug方式,希望对大家有所帮助
【黑马程序员java培训就业班笔记：day05总结】相关文章：
黑马程序员python笔记04-19
黑马程序员PHP培训教程：同步和异步05-07
黑马程序员面试技巧08-14
黑马程序员C语言教程：QSignalMapper的使用04-14
Java从入门到精通读书笔记—c++程序员学java04-18
尚学堂Java培训高级Java程序员值得拥有的10本书04-16
“黑马”作文04-27
黑马王子灯塔线范文06-11
黑马王子作文500字05-04