System.out.println（i+"是"+strArr[i]）;
}
}
}
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
2015-07-22
Ø变量
<1>声明：
变量声明时没有内存分配
<2>初始化：
一般声明的时候不要初始化new关键字分配内存空间
<3>变量的调用：
作用域生命周期
局部变量：
>>定义在方法内部
>>作用域在声明所在的大括号内。
>>生命周期从变量初始化被调用开始，超出作用域会被标记为可回收，自动回收。
成员变量：
类内的方法外部的非静态变量，又称为属性。
>>作用域是类内所有的方法。
>>生命周期与所在对象的生命周期一致。
静态变量：
第一次调用的时候分配内存，直到程序结束。
类是抽象的，对象能被销毁
>>定义在类内方法外，类变量，不是属性。
>>通过类的名字.直接调用。
作用域和成员变量一样。
>>通过对象调用也可以，多个对象共享一块内存，不属于某个对象。
//短路算法null判断在在前
if（uname!
=null&&pwd!
=null&&!
uname.equals（""）&&!
pwd.equals（""））{
//避免出现空指针异常错误
}
Ø对数组的声明和初始化
publicvoidtestSz（）{
int[]sz;//数组的声明
String[]sz2;
User[]users;
sz=newint[5];//数组的首地址在栈里，在heap中分配5个连续的4字节内存空间
sz2=newString[5];
users=newUser[5];
sz2[0]="a1";//在heap中分配内存"a1"，然后把首地址给sz2[0];
sz2[1]=newString（"a2"）;
users[0]=newUser（）;//在heap中分配内存User，然后把首地址给users[0];
}
Ø断点调试
双击左边空白处，设置断点à右键àdebug
F6单步调试
F8从当前断点跳到下一断点，如果没有，结束调试
Ø抽象和封装
Ø抽象：
从对象个体中提取他们的共同的特征，形成一类物体Class
Ø对象：
具体的个体——在计算机中，对象是类的实例（可以分配内存的，这个过程叫做实例化）Useru//对象的声明u=newUser（）///对象的实例
Ø面向对象的提取过程
⏹提取所有的名词性概念——生成概念模型（需求分析阶段）
名词可以生成类或者类的属性
⏹找动词——提取方法
Ø导包的快捷键ctl+alt+o
ØThis：
类的当前对象
Ø构造方法：
（1）给必要的属性初始化把局部变量赋值给成员变量
（2）成员变量先赋值再执行构造函数。
Ø构造方法特点
<1>方法名和类名一致（首字母大写）
<2>没有返回值
<3>一个类有多个构造方法
有参数的构造中参数传进去的是必要的信息，区别于对象中的赋值。
//把局部变量的值赋值给成员变量
//在构造方法里设置默认值
抽象的类属性不能有具体的值，除非默认属性值在构造函数中初始化
publicDog（Stringname）{//必要信息作为参数
this.name=name;//局部变量给成员变量
this.health=70;//设置默认值
}
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
2015-07-23
Ø软件的要求：
高内聚低耦合、
ØSRP：
simpleresponsiblepriniple简单责任原则
OCP：
Opencloseprinciple开放关闭原则对于功能的扩展是opened对于功能的修改时closed
ØOop的三大特点是：
封装继承多态
Ø抽象是把对象共有的特征抽取成类。
Ø封装：
目的是—安全
Ø封装的步骤：
<1>属性设置成private
<2>添加setget方法
<3>在set中过滤不合理的入参
Ø如何设置只读属性:
<1>通过构造函数的参数给属性赋值
<2>把属性的set方法删除
Ø用于封装的常用关键字：
privatepublicprotected默认
Ø对象的初始化方法：
1.通过构造函数，传入参数，给必要的属性初始化，同时可以设置默认值
2.通过对象.属性的方法初始化对象
3.publicvoidinit（）{}
private关键字：
只有类的内部可以调用
public关键字：
访问权限最大，类的内部对象都可以调用
注意：
局部变量必须初始化，属性可以不用初始化
Østatic关键字：
1．常量的定义：
static+final关键字
常量特点
<1>永远不会变化
<2>不会占用内存在编译的时候已经写死了，编译到源文件里，节省内存
<3>举例子用PI先配置，再使用，直接在源代码修改常量value
变量用final关键字赋值一次后也不能改变。
所以值是否可改不是常量的专有特点。
变量在编译的时候占内存。
ØStatic变量和static方法
●静态变量：
第一次调用的时候分配内存，直到程序结束。
类是抽象的不分内存，对象能被销毁
<1>类变量，不是属性。
<2>通过类的名字.直接调用
<3>通过对象调用也可以，多个对象共享一块内存，不属于某个对象
●静态方法：
类方法,静态方法中只能有静态变量和方法
●静态方法和属性的关系：
<1>静态方法可以直接调用静态属性，但是不能直接调用所在类的非静态属性。
<2>静态方法不使用this（静态属性也不使用this）关键字。
注意：
在方法内部不能够定义一个static局部变量
补充：
成员变量和局部变量冲突的时候用this区别，静态变量和局部变量冲突的时候用类名.来区别。
局部变量优先。
publicclassPetSex{
publicstaticfinalStringMALE="male";
publicstaticfinalStringFEMALE="female";//常量static+final关键字内存不变值也不变
publicfinalStringF_MALE;//final修饰后的变量
publicstaticStringT_MALE="male";//静态变量值可以改变，内存不变，用类名调用
publicstaticStringT_FEMALE="female";
publicPetSex（）{//使用场景：
配置文件的读取，如数据库连接
this.F_MALE="male";//只允许赋一次值，然后就不能改变了
}
publicstaticvoidtestStatic（）{
//在静态方法中，不能直接调用所在类的属性
//System.out.println（this.F_MALE）;
//Cannotusethisinastaticcontex
PetSexp=newPetSex（）;
//System.out.println（p.F_MALE）;
StringT_MALE="DDDDD";//重名的时候，局部变量优先
System.out.println（T_MALE）;//DDDDD
System.out.println（PetSex.T_MALE）;//输出上面的静态变量
}
}
方法的重载：
方法名相同参数列表不同与返回值和修饰符无关
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
2015年7月27日星期一
作业包装和equals
复习三种变量
复习了equles和==区别。
对象是否相同看首地址和类型是不是相同。
ØXml可扩展性标记语言讲解见文档xml讲解
ØStack和heap的区别和关系（内存管理机制pdf）
Ø装箱与拆箱的定义作用和重要的类？
（见ppt）
作用：
JAVA一切皆对象。
多线程，反射，哈希。
多线程下基本数据类型是无法操作的，所以要包装。
List是个典型的并发环境，并发环境下需要使用引用，基本数据类型办不到。
为了让他按对象处理。
为什么要使用包装类？
（1）为了在各种类型的转换
（2）有时候，一个函数需要传递一个Object类型的变量，而你想传递int类型的，所以使用包装类利于传值
（3）当需要往ArrayList,Hashmap中放东西时，像Int，double这种基本类型放不进去，因为容器都是装的object的。
多线程下基本类型没有办法引用基本类型，比如说集合ArrayList，它是一个并发环境，如果往里面放int,放不进去，所以想让它当对象处理必须用包装类。
●装箱：
基本数据类型转为对象类型。
intk=100;
Integerkk=k;//自动装箱
●拆箱：
对象类型转为基本类型
●包装类：
Byte,Character,Boolean,Short,Integer,Long,Double,Float
装箱的步骤：
（1）创建包装器对象。
除Character之外，所有的包装器都提供两个构造函数，一个是基本类型，一个是字符串。
Integeri1=newInteger（10）;
Integeri2=newInteger（"10"）;
Character类只提供一种构造函数Characterc1=newCharacter（'a'）;
（2）通过对象的构造函数，或者使用valueOf（）方法实现装箱操作：
booleanaa=true;
Booleanab=newBoolean（aa）;
Booleanac=newBoolean（"true"）;
booleanc=true;
Booleand=Boolean.valueOf（c）;
Booleane=Boolean.valueOf（"true"）;
拆箱的步骤：
（1）直接用parseXX（）方法：
它是由Byte,Short,Integer,Long,Float,Double,Boolean包装器提供的一个类的静态方法,用于实现String到基本类型的转换（Character除外）
ex：
inta=Integer.parseInt（"10"）;
（2）xxValue（）方法
所有包装器的对象都提供了一个相应方法,用于返回到基本类型，即拆箱操作
Integeraa=newInteger（10）;
intbb=aa.intValue（）;
4继承：
（1）优点：
大量减少子类中重复代码（重复代码抽取法）
子类和父类之间是is-a的关系。
如DogisaPet
Ø组合（composite）或者聚合（aggregate）：
---------has-a的关系例如：
Aggregate（byvalue,byreference）班级和学生的关系（byreference生命期不一致）学校和班级的关系（byvalue生命期一致）
Ø父类属性提取方法：
<1>提取所有子类的共性属性和方法
父类的构造方法先执行
//通过子类，像父类传参数
ImplicitsuperconstructorPet（）isundefined.Mustexplicitlyinvokeanotherconstructor
<2>删除子类中的重复属性
继承：
子类会继承父类的非似有的属性和方法
知识点：
子类和父类之间属性和构造方法的执行顺序
<1>子类和父类的属性同时赋初始值
<2>先调用父类的属性赋值privatedoubleage=4;
<3>调用父类的构造函数，给父类的属性赋值
publicPet（Stringname）{
this.name=name;
this.health=70;
}
<4>给子类的属性赋值privatedoubleage=3;
<5>调用子类的构造函数，给相关属性赋值【看7-27的PetGame中的dog和pet】
publicDog（Stringname）{//子类的构造方法会自动去先调用父类同等结构的构造方法
super（name）;//一定要在第一句
this.name=name;//把局部变量的值，赋给成员变量（当局部变量与成员变量同名时，局部变量优先）
this.health=80;//设置属性默认值
}
Dogdog=newDog（）;内存只有一块，父类和子类对象都在里头
（3）重写override子类和父类有同名同参的方法
子类和父类拥有同名同参的方法，调用时会调用子类的这个方法
Ø编译与预编译：
预编译又称为预处理，处理以#开头的指令，做些文本代码的替换工作。
Ø封装的几个关键字对比：
（1）private：
只有类内的方法和属性才能使用（作用域是类内）
（2）Public：
子类和对象都可以调用（从任何地方都可以调用属性和方法）
（3）Protected：
子类可以直接调用父类的属性和方法（不区分包内包外）；
同一包内的对象可以调用。
（Dogdog=newDog（）;dog.name="aaa";）
（4）默认：
包内（对象和子类）都能调用。
主要用于修饰类。
仅限于包内。
classPet{}，这样即使你做了jar包的引用，也不能使用某些类
所以调用属性或方法的三种：
类内调用；对象调用；子类调用
this：
对象本身；super：
父。
publicCat（Stringname）{
super（name）;
super.swim（null）;
super.age=10;
}
Ø子类重写了父类的方法之后，Dogdog=newDog（）;t=dog.getAge（）;----调用子类的getAge（）方法。
Petpet=（Pet）dog;
T=pet.getAge（）;-------------调用子类的方法，因为子类已经把父类的给覆盖了
Ø子类可以继承父类哪些成员：
非私有成员
Dogdog=newDog（"旺财"）;
Petpet=（Pet）dog;---------子转父，是安全的转换
Petpet=newPet（"ddd"）;
Dogdog=（Dog）pet;-------父转子，可能会出错
if（petinstanceofDog）{
Dogd=（Dog）pet;
System.out.println（"类型转换成功"）;
}
Ø抽象类中可以写抽象方法：
publicabstractvoidplay（）;-----非抽象类中不能写抽象方法
子类如果是非抽象类，就必须重写父类的抽象方法。
Øfinal关键字的4种使用方法：
1.用于修饰class，使该class不能被继承
2.方法不希望被重写，可以使用final修饰----如打好jar包的类库
3.属性不希望被修改，用final修饰
4.finalDog=newDog（）;锁住引用。
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
2015-7.28周二
1、宠物的color属性是放在子类好、还是父类好？
有些属于子类的特有属性和行为，放在父类则透明性好，放在子类则安全性好。
问题：
透明与安全。
2、抽象类的特点：
不能实例化。
This与super的区别：
？
（1）this代表对象自身。
Super代表父类。
（2）子类和父类都同时有同名的变量（name）时，this.name是找的是子类的name（子类父类都定义）；子类没有name的时候，this.name调用的是父类的。
PrivatefinalStringip="10.0.1.2";//在这里直接赋值之后，就变成了常量。
PrivatefinalStringip;//在这里定义，在构造方法里赋值，这里是变量。
FinalDogdog=newDog（"旺财"）;
dog.setName（"缓缓"）;//final修饰引用类型的变量，变量的值是不变的，变量指向的对象的值是可变的
汽车租赁项目练习：
1、抽取名词性概念：
汽车；租赁公司、车型、日租金；常量：
别克商务、宝马550
2、抽取动词：
出租单辆车、出租多辆车
3、抽象class：
4、名词不是类就是属性。
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
2.015-7.30星期四接口
1、接口：
接口是对象能力的表示
类是单线继承的，不允许多重继承（使用接口达到多重继承）
2、接口的命名：
（1）按照能力的语言表示。
直接命名：
Swim
（2）匈牙利命名法：
ISwim
（3）SwimInterface
3、接口的特点：
（1）所有的方法都强制为抽象方法
（2）一个接口中可以写多个与接口相关的抽象方法
（3）某个类实现了接口，就要重写接口中的所有的抽象方法
（4）一个类可以实现多个接口
（5）接口中不能存在属性，可以有常量
***********面向接口的编程*********************publicvoidSwim（ISwim[]pets，Poolpool）
作业：
自学enum类型。
接口与抽象类的区别：
（1）抽象类里可以有属性，接口中只能有方法和常量
（2）抽象类中可以有方法的实现---------------接口中都是抽象方法
多态：
形参使用的是父类
升级会员 