Java语言程序设计基础笔记.docx
- 文档编号:7510318
- 上传时间:2023-01-24
- 格式:DOCX
- 页数:14
- 大小:22.62KB
Java语言程序设计基础笔记.docx
《Java语言程序设计基础笔记.docx》由会员分享,可在线阅读,更多相关《Java语言程序设计基础笔记.docx(14页珍藏版)》请在冰豆网上搜索。
Java语言程序设计基础笔记
1、类属性、实例属性的区别
*没有static修饰的变量称为实例变量,有static修饰的变量称为类变量(或静态变量)
*类变量只属于类本身,不属于对象
*类变量在整个类中只有一个值
2、静态方法(类方法)
*一个静态方法只属于一个类本身,而不属于某个类
*静态方法和静态变量的引用直接通过类名引用
*在静态方法中不能调用非静态的方法和引用非静态的成员变量,反之则可以可以用类的对象去调用静态的方法
3、类成员访问修饰符与访问能力之间的关系
*public无约束
*protected同一类、子类
*default同一类、同一包
*private同一类
4、方法的重载(overloding)与重写(overriding或overwriting)
●方法的重写要求方法签名必须相同,而方法的重载要求方法签名必须不同
●方法的重写放回类型必须一致,而方法的重载则没有要求。
●异常也不会影响重载,而重写子类的异常必须与父类一样或属于父类异常的一种或无
●方法的重写只局限与子类和父类之间,而方法的重载可以在一个类的所有方法之间
●方法的重载对类的修饰没有要求,而方法的重写子类方法的修饰限制一定要比父类的小
5、final
6、变量的初始化问题
*局部变量在定义时必须初始化,如果是方法的形参,则通过调用方法时实参的传递初始化(方法的形参也属于局部变量)
*如果是对象的实例变量,则不用必须初始化.系统会默认地为对象的实例变量赋初值,但这样做只能保证程序编译运行正常,而无实际意义.所以一般对象的实例变量要在构造方法中赋初值(boolean默认为false;char默认为?
)
*作为类成员,只能声明时候初始化,否则就要到方法中初始化
7、””和null的区别
8、super
*特殊变量super提供了对父类的访问
*可以使用super访问父类被子类隐藏的变量或覆盖的方法
*每个子类的构造方法的第一条语句都隐含调用super();如果父类没有这种形式的构造函数,那么在编译时会报错
*构造方法不能被继承只通过super调用
9、构造方法
*如果父类没有无参的构造方法,那么在子类中就必须声明构造方法且不能声明无参构造方法;这样子类中的就必须显式调用父类中的某个构造方法;个人觉得如果有继承关系的一般属性定义为protected,个人觉得bean定义为private,或protected也可以
*或者不声明构造方法,如果声明构造方法,通常至少声明两个,其中一个为无参的构造方法
*子类的构造的过程中必须调用其基类的构造方法;子类可以在自己的构造方法中使用super调用基类的构造方法;使用this调用本类中的另外的构造方法
*this(“”,””,””)这样的形式定义无参构造方法,那么必须有全部成员变量的构造方法
10、继承[组合]【覆盖】
*接口可以实现多继承,而类不可以实现多继承
*子类不能继承父类的私有属性和方法,且不能继承构造方法
*子类不能继承父类的静态属性和方法,只能被调用
*子类不能直接访问从父类的是有属性及方法,但可以使用公有的(及保护)方法进行{一般使用getX()得到}
*什么时候构造方法必须调用{例如:
有些模式就一定要自己定义构造函数,比如设计模式中的单例模式
也就是这个类只允许一个实例产生
class Singleton {
private static Singleton instance = null;
private Singleton() {//定义为私有,只能由内部的getInstance方法调用,确保只能产生一个实例即instance,如果你不定义私有构造函数,那么默认提供的是public,也就不能保证单例了
}
synchronized public static Singleton getInstance() {
if (instance == null)
instance = new Singleton();
return instance;
}
}}
11、static
*在类中,用static声明的成员变量为静态变量,它为该类的公用变量,在第一次使用时被初始化,对于该类的所有对象来说,static成员变量只有一份
*用static声明的方法为静态方法,在调用该方法时,不会将对象的引用传递为它
,所以在static方法中不可访问非static的成员[静态方法不再是针对某个对象调用,所以不能访问非静态成员]
*可以通过对象引用或类名(不需要实例化)访问静态成员
*静态方法不能调用非静态的属性或方法【因为局部不代表全部】
*类成员只有在new一个对象的时候才存在
static方法不需要new对象就可以调用,那么在static方法里面怎么可以使用一个还不存在的成员呢?
!
*并发和静态不是很相关
多个人对同一个东西的使用肯定有并发问题
有没有并发关键看你怎么设计你的数据层
方法就是一段程序,什么程序都是消耗内存的。
静态变量常驻内存,说他消耗也可以
静态方法通常比非静态方法快
静态方法多为工具方法,就是说静态方法不引用外部资源所以编译更快。
所有操作数据库的方法这句话不是很明白
操作数据库简单的就是,查询,插入删除,
这些方法需要数据库链接,楼主是想维护静态连接池呢还是不停打开链接呢
不推荐使用静态方法作数据库操作,因为数据库方法带有延伸性。
就是说一般静态方法都是得到数据,计算,返回数据
而数据库方法则是,得到数据,发到数据库,得到返回结果,返回数据。
直觉上就跟静态方法的名字冲突。
不够清晰
隐藏与覆盖
//所谓隐藏是指,子类能隐藏父类的变量和方法,通过子类对象,不能访问父类被隐藏了的变量和方法,
//但是将子类对象转换成父类对象时,可以访问父类中被隐藏的变量和方法
//而覆盖则指,子类能覆盖父类的方法,通过子类对象,不能访问父类被覆盖了的方法
//将子类转换成父类对象时,也不能访问父类中被隐藏的方法。
//方法可以被隐藏和覆盖,但是变量只可能被隐藏,不会被覆盖
12、多态
*多态存在的必要条件1,要有继承2,要有重写3,父类引用指向子类对象
属性沒有多态性,只有方法才有多态性
*当我们将子类对象引用传给声明为父类对象,如果子类有的方法就调用子类的方法,否则调用父类的方法{静态方法?
}
*静态方法,即是什么的引用就调用什么方法
*方法的重写Overriding和重载Overloading是Java多态性的不同表现。
重写Overriding是父类与子类之间多态性的一种表现,重载Overloading是一个类中多态性的一种表现。
13、final
*final的变量的值不能被改变
final的成员变量
final的局部变量(形参)
*final的方法不能被重写,程序运行速度快
*final的类不能被继承
★final存在的理由:
1、安全方面2、设计方面:
从面向对象设计方便,如希望声明的类为最终类,则最好或从概念将该类不应该有任何派生类
14、自定义异常
PublicclassMyExceptionNameextendsSuperclassOfMyException{
PublicMyExceptionName(){
super(“”);
}
}
15、抽象类
*用abstract关键字来修饰一个类时,这个类叫做抽象类;
*用abstract来修饰一个方法时,该方法叫做抽象方法
*含有抽象方法的类必须被声明为抽象类,抽象类必须被继承,抽象方法必须被重写
*抽象类中也可以有非抽象的方法,也可以没有抽象方法
*抽象类不能被实例化即是不能有new
*抽象方法只需声明,而不要实现
*不能有抽象构造函数或抽象静态方法
*抽象类可以实现接口不需要实现里面的方法
16、引用对象数组
*引用对象数组一定要初始化
*元素为引用数据类型数组中的每一个元素都需要实例化
*引用对象占用两块内存
17、包的使用
*当导入一个包中的所有类,则需内存存储类的名字,占内存的,对于pc机无影响,但对手持设备不然
*基本数据类型及数据包裹类
*提供线程操作和管理的类是Tread类
*valueOf()比Integer.parseInt()通用,后面只包括Integer,Float,Double,Long,Byte,Short
18、Interface
*java允许省略声明数据成员的final,方法的public及abstract关键字
*接口也可以继承(称为接口的扩展),并且可以继承多个接口;但不可以实现
*类的继承与接口继承的区别
19、面向对象的设计原则
*开闭原则
*接口隔离原则
20、塑型
*基本数据类型的塑型(强制转换不会四舍五入(int)2.6结果是2)
*对象的塑型:
方法的查找(类方法,实例方法)
21、内部类
classMeal{
Meal(){
System.out.println("Meal()");
}
}
classBread{
Bread(){
System.out.println("Bread()");
}
}
classCheese{
Cheese(){
System.out.println("Cheese()");
}
}
classLettuce{
Lettuce(){
System.out.println("Lettuce()");
}
}
classLunchextendsMeal{
Lunch(){
System.out.println("Lunch()");
}
}
classPortableLunchextendsLunch{
PortableLunch(){
System.out.println("ProtableLunch()");
}
}
publicclassSandwichextendsPortableLunch{
Sandwich(){
System.out.println("SandWich()");
}
Breadbread=newBread();
Cheesecheese=newCheese();
Lettuceley6ttuce=newLettuce();
publicstaticvoidmain(String[]args){
Sandwichsandwich=newSandwich();
Sandwich.cheese.getName();
}
}
结果:
Meal()
Lunch()
ProtableLunch()
Bread()
Cheese()
Lettuce()
SandWich()
从上面的例子可以看出创建一个派生类,构造方法的调用次序为:
基类构造方法;成员变量的初始化;派生类构造方法。
*调用基类的构造方法*按声明顺序调用成员初始化模块*调用派生类构造方法
22、构造方法中的多态方法
abstractclassGlyph{
abstractvoiddraw();
Glyph(){
System.out.println("Glyph()beforedraw()");
draw();
System.out.println("Glyph()afterdraw()");
}
}
classRoundGlyphextendsGlyph{
intradius=1;//这里如果加上final就不会出现错误了
RoundGlyph(){
System.out.println("RoundGlyph.RoundGlyph(),radius="+radius);
}
@Override
voiddraw(){
System.out.println("RoundGlyph.draw(),radius="+radius);
}
}
publicclassPolyConstrutor{
publicstaticvoidmain(String[]args){
newRoundGlyph();
}
}
结果:
Glyph()beforedraw()
RoundGlyph.draw(),radius=0
Glyph()afterdraw()
RoundGlyph.RoundGlyph(),radius=1
在定义构造方法时,遵循以下原则能够有效地避免错误:
*用尽可能少的动作把对象的状态设置好
*如果可以避免,不要调用任何方法
*在构造方法内惟一能安全调用的是在基类中具有final属性的那些方法(也适用private,它们自动具有final属性)。
这些方法不能被覆盖,所以不会出现上述潜在问题
在构造方法中要尽可能避免调用具有多态的其他方法,以免在对象还没有完全构造以前调用其方法成员。
也就是说,构造方法尽可能的简单,其目的的仅仅是给对象进行初始化,不要在构造方法中编写与初始化无关的其他功能。
23、单例模式
单例的目的:
保证一个类只有单一的实例,也就是说你无法通过new来创建这个类的一个新实例。
单例的好处:
当一个对象在程序内部只能有一个实例的时候,它可以保证我们不会重复创建,而是始终指向同一个对象
代码:
第一种:
在声明变量时实例化(也叫饿汉式单例模式),代码如下:
publicclassSingleton{
privatestaticSingletoninstance=newSingleton();
privateSingleton(){}
publicstaticSingletongetInstance(){
returninstance;
}
}
第二种:
把对象的创建放到方法里面去(也叫懒汉式单例模式),代码如下:
publicclassSingleton{
privatestaticSingletoninstance=null;
privateSingleton(){}
publicstaticsynchronizedSingletongetInstance(){
//也可以这样写:
synchronizedpublicstaticSingletongetInstance(){
if(instance==null){
instance=newSingleton();
}
returninstance;
}
}
各自的优缺点:
第一种饿汉式:
优点:
在类加载初始化的时候就创建对象,调用getInstance的时候,没有同步方法,运行时性能较高。
缺点:
类加载速度慢,占用太多大的资源空间。
第二种懒汉式:
优点:
避免了第一种方式的缺点,同时,可以在多线程下运行安全。
缺点:
因为他使用了锁,在运行中效率慢。
24、循环语句
*switch语句中表达式必须是整型(byte、short、int)或字符型(char)
*switch可以使用break、也可以使用return
*default可以没有
*for语句的三个表达式都可以为空,但是其间的分号不能省略。
若表达式check-expression为空,则表示当前循环是一个无限循环,需要在循环体中增加跳转语句终止循环。
*while与do-while:
do-while如果表达式不成立也会先执行一次。
正常情况下while和do-while的循环次数一致的
*publicclassTest2{
publicstaticvoidmain(String[]args){
outer:
for(inti=1;i<=9;i++){
for(intj=1;j<=i;j++){
if(j>i){
break;
}
if(i==6)
breakouter;
System.out.print(""+i+"*"+j+"="+i*j);
}
System.out.println();
}
}
}
*break和continue的区别
Continue跳出循环继续当前循环的下一轮而break是跳出当前循环
25、try-catch-finally
finally在return之前执行
通常finally块的作用是用于释放资源
26、Set与List
*set的数据对象没有顺序并且不可以重复
*TreeSet实现SortedSet接口
*SortedSet是一种特殊的Set,其中的元素是升序排列的,并且还增加了与次序相关的操作,通常用于存放词汇表这样的内容
*List的数据对象有顺序并且可以重复
*SortedMap是一种特殊的Map,其中的关键字是升序排列的,它是与SortedSet对等的Map,通常用于词典和电话目录,TreeMap
27、ArrayList与Vector
*Vector不能存储基本数据类型的数据,除非讲这些数据包裹在包裹类中
*Vector.remove(intindex),Vector.remove(Objecto)如果index不存在就会抛异常,而Object不存在,相当于不做任何事情,也不会出现异常
*ArrayList和Vector都是使用数组方式存储数据,插入数据慢;LinkedList使用双向链表实现存储,插入数据快
*同步性:
Vector是线程安全的,也就是说是同步的,而ArrayList是线程序不安全的,不是同步的;数据增长:
当需要增长时,Vector默认增长为原来一培,而ArrayList却是原来的一半
28、Arrays与Collections
29、Enumeration及Iterator类
*Enumeration不能用于ArrayList对象,而Iterator类既可以用于ArrayList也能用于Vector对象
*Iterator类中有remove()方法,而Enumeration类中没有remove()方法
publicclassEnumerationTest2{
publicstaticvoidmain(String[]args){
String[]num={"one","two","three","four"};
Vector
System.out.println("BeforeVector:
"+vector);
for(Enumeration
StringaString=e.nextElement();
System.out.println(aString);
if(aString.length()>4){
vector.remove(aString);
}
}
System.out.println("AfterVector:
"+vector);
}
}
BeforeVector:
[one,two,three,four]
one
two
three
AfterVector:
[one,two,four]
从上面的结果看到,长度大于4的字符串并没有如预期的那样都从向量中去除。
这是Enumeration类中存在。
因此,如果在遍历的过程中去除对象,就不要使用Enumeration类
publicclassIteratorTest1{
publicstaticvoidmain(String[]args){
String[]num={"one","two","three","four"};
Vector
System.out.println("BeforeVector:
"+vector);
for(Iterator
StringaString=e.next();
System.out.println(aString);
if(aString.length()>4){
e.remove();
}
}
System.out.println("AfterVector:
"+vector);
}
}
BeforeVector:
[one,two,three,four]
one
two
three
four
AfterVector:
[one,two,four]
从遍历的过程中,Iterator类中对象能够与对其对应的集合对象保持一致,没有元素被遗漏,因此能够得到正确的结果。
30、HashTable与HashMap
一.历史原因:
Hashtable是基于陈旧的Dictionary类的,HashMap是Java1.2引进的Map接口的一个实现
二.同步性:
Hashtable是线程安全的,也就是说是同步的,而HashMap是线程序不安全的,不是同步的
三.值:
只有HashMap可以让你将空值作为一个表的条目的key或value
31、Thread类与Runnable接口的区别
*Runnable接口的好处不仅在于间接解决了多继承问题,与Thread类相比,Runnable接口适合于多个线程处理同一资源。
*用三个线程模拟三个售票口,总共售出200张票
publicclassEx8_6{
publicstaticvoidmain(String[]args){
SellTicketst=newSellTicket();
newThread(st).start();
newThread(st).start();
newThread(st).start();
}
}
classSellTicketimplementsRunnable{
privateinttickets=200;
publicvoidrun(){
while(tickets>0){
Syst
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- Java 语言程序设计 基础 笔记