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)抽象类中可以有方法的实现---------------接口中都是抽象方法
多态:
形参使用的是父类