JAVA笔记分析.docx
- 文档编号:23749624
- 上传时间:2023-05-20
- 格式:DOCX
- 页数:41
- 大小:578.01KB
JAVA笔记分析.docx
《JAVA笔记分析.docx》由会员分享,可在线阅读,更多相关《JAVA笔记分析.docx(41页珍藏版)》请在冰豆网上搜索。
JAVA笔记分析
JAVA中一些需要特别注意的地方
一、JAVA-SE部分:
byte范围(占8位):
-128~127
short范围(占16位):
-32768~32767
int范围(占32位):
-2147483648~2147483647
long范围(占64位):
1.关于引用传递的问题:
所谓的引用传递,就是将一个堆内存空间的使用权给多个栈内存空间,每个栈内存空间都可以修改堆内存中的内容
所有的对象名称都在栈内存中保存,而对象的具体内容则保存在对应的堆内存中,更准确的说法就是在栈内存中实际保存的是堆内存空间的访问地址
具体内存分配如下:
使用new开辟堆内存空间
存储引用(实例)
指向对应的堆内存
存储对象
Name=null;
Age=0;
堆内存
per
栈内存
Personper=newPerson();
例如现在new一个对象:
Personper1=newPerson();
现在又有如下语句:
Personper2=null;per2=per1;
那么设置per2对象的内容实际上就是设置per1对象的内容,假如per1对象的name、age属性值分别为“张三”、23,那么通过以下语句可以修改per1对象的属性值:
per2.name="李四";per2.age=32;那么:
Per1.name="李四";per1.age=32;
注意:
匿名对象只在堆内存中开辟空间,而不会在栈内存中开辟空间
2.length和length()的区别:
使用length取得数组的长度
使用length()方法取得字符串的长度
3.访问控制权限:
(1)private访问权限:
private属于私有访问权限,可以用在属性的定义、方法的声明
上,一旦使用了private关键字声明,则只能在本类中访问;
(2)default(默认)访问权限:
如果一个类中的属性或方法没有使用任何的访问权限声明,
则就是默认的访问权限,默认的访问权限可以被本包中的其
他类所访问,但是不能被其他包中的类所访问;
(3)protected访问权限:
protected属于受保护的访问权限,一个类中的成员如果使用了
protected访问权限,则只能被本包及不同包的子类所访问;
(4)public访问权限:
public属于公共访问权限,如果一个类中的成员使用了public访
问权限,就可以被所有的类访问,不管是不是在同一个包中。
对以上所述列表如下:
类访问修饰符
序号
说明
1
类的修饰符只有public和default两个;
2
public修饰类时表示任何包的其它类都可以访问该类;
3
访问修饰符为default时只有在同一个包里的类才能访问它,其他包里的都不行;
4
类的构造函数(构造器)不能用final、abstract、synchronized、native、static等关键字进行修饰;
5
特殊说明:
成员内部类除了可以用成4种员访问修饰符外,还可以用static修饰;
局部内部类【类方法里定义的内部类】只能使用abstract或者final修饰。
成员访问修饰符(public、protected、default、private)
序号
规则说明
1
java的成员访问修饰符有4种:
public、private、protected、default
2
publicstatic==staticpublic;
3
类的成员访问修饰符的详细描述如下:
(√表示允许访问,×表示不能访问)
visibility
public
protected
default
private
在本类中能否访问
√
√
√
√
在同一个包中不同的类中能否访问
√
√
√
×
在不同包的子类中能否访问
√
√
×
×
在不同的包中不同的类中能否访问
√
×
×
×
综合上表,访问修饰符的访问权限为:
public>protected>default>private
4.关于==和equals的区别:
当使用==来判断两个变量是否相等时,如果两个变量是基本类型变量,且都是数值类型(不一定要求数据类型严格相同),则只要两个变量的值相等,就将返回true;但对于两个引用类型的变量,只要他们指向同一个对象,==判断才会返回true。
例如以下程序:
publicclassStringDemo{
publicstaticvoidmain(String[]args){
Stringstr1="hello";
Stringstr2=newString("hello");
Stringstr3=str2;
Stringstr4="ab"+String.valueOf(88);
System.out.println(str1==str2);
System.out.println(str1==str3);
System.out.println(str2==str3);
System.out.println(str4=="ab88");//打印false
Strings1="疯狂Java";
Strings2="疯狂"+"Java";
System.out.println(s1==s2);//打印true
Strings3="疯狂";
Strings4="Java";
Strings5="疯狂Java";
Strings6=s3+s4;
System.out.println(s6==s5);//打印false
}
}
程序的输出结果为:
falsefalsetruefalsetruefalse
对于str1和str2来说,其内容分别保存在堆内存的不同地址空间中,所以即使内容相同,但是地址的值是不相同的,所以str1和str2比较不相等。
而str2和str3指向同一堆内存空间,是同一地址,所以最终结果str2和str3的地址值是相同的。
同理,str1和str3的地址也不相等,所以返回了false。
至于str4,由于该变量的值需要调用String类的方法,编译时无法确定str4的值。
至于s6,他的值由s3和s4进行连接运算后得到,由于s3和s4只是两个普通的变量,编译器不会执行“宏替换”,编译时无法确定s6的值,也就无法让s6指向字符连接池中缓存的"疯狂Java"。
要让s6==s5输出true也很简单,只要s3和s4都用final修饰,这样在执行对s6的拼接时就会执行对s3和s4的宏替换,这样编译器在编译阶段就可以确定s6的值,就会让s6指向缓存的"疯狂Java"。
从上面的例子可以看出==是用来进行堆内存地址值比较的,如果要判断两个字符串的内容是否相同,则用String类提供的equals方法。
如果要自定义任意两个对象是否相等,可以重写equals方法来实现,因为Object默认提供的equals方法只是比较对象的地址,即Object类的equals方法比较的结果与==运算符比较的结果完全相同。
5.String两种实例化方式的区别:
第一种实例化方法:
Stringstr1="hello";
Stringstr2="hello";Stringstr3="hello";
虽然申明了3个字符串变量,但这三个字符串指向的堆内存地址
空间都是同一个,也就是说只要以后申明的字符串内容相同,则
不会再开辟新的内存空间
第二种实例化方法:
Stringstr=newString("hello");
使用这种方法时,不管如何都会再开辟一个新的空间
6.普通代码块、构造块、静态代码块:
普通代码块:
直接在方法或者语句中定义的代码块;
构造块:
直接写在类中的代码块;
静态代码块:
用static关键字申明的代码块;
特点:
构造块优先于构造方法执行,而且每次实例化对象时都会执
行构造块中的代码;
主方法所在的类中定义的静态代码块优先于主方法执行
【注:
静态代码块不能定义在主方法内】;
在类中定义的静态块会优先于构造块和构造方法的执行,而
且不管有多少个对象产生,静态代码块只执行一次。
Java中静态初始化块、初始化块和构造方法的执行顺序:
当该类没有父类时顺序是这样的:
第一次创建对象时:
静态代码块> 初始化代码块 >构造方法
第二次创建对象时:
初始化代码块 >构造方法静态代码块只执行一次
当该类有父类时顺序是这样的:
classParent{
publicstaticStringp_StaticField="父类--静态变量";
publicStringp_Field="父类--变量";
//代码块
{
System.out.println(p_Field);
System.out.println("父类--初始化块");
}
//构造函数
publicParent(){
System.out.println("父类--构造器");
}
//静态初始化块
static{
System.out.println(p_StaticField);
System.out.println("父类--静态初始化块");
}
}
publicclassStaticBlockextendsParent{
publicstaticStrings_StaticField="子类--静态变量";
publicStrings_Field="子类--变量";
{
System.out.println(s_Field);
System.out.println("子类--初始化块");
}
//静态初始化块
static{
System.out.println(s_StaticField);
System.out.println("子类--静态初始化块");
}
publicStaticBlock(){
System.out.println("子类--构造器");
}
publicstaticvoidmain(String[]args){
System.out.println("-------------------");
newParent();
System.out.println("-------------------");
newStaticBlock();
System.out.println("-------------------");
newStaticBlock();
1、执行子类StaticBlock之前,由于父类中也有静态的变量,根据继承的特性,则先执行父类Parent的静态数据的初始化,然后再执行子类的静态数据的初始化;
2、执行main方法中的newParent();语句,进行Parent的类的实例化,因为Parent的静态数据已经实例化,并且在一个执行过程只实例化一次,所以在执行newParenet()语句时,先执行非静态变量定义和类的非静态语句,之后再执行构造方法;
3、执行main方法中的newStaticBlock();语句,进行子类的实例化,父类和子类的静态数据不执行,因为子类继承Parent,所以首先执行父类的非静态的变量和类语句的执行,再调用父类的同参数的构造方法,然后执行子类的实例化
1.静态初始化块只在某个类第一次装入内存时才执行,因此只有第一次newParent()才有“静态初始化块”输出,而后面却不执行输出。
总结如下:
(1)先静态。
具体是先父静态->子静态
(2)先父后子。
先父的全部,然后子的全部。
(3)优先级:
父类>子类。
静态代码块>非静态代码块>构造函数 (与位置的前后无关系)
先静态,可以这么理解,只要出现了某类的关键字,那么这个类的类变量或方法就要初始化,否则引用的时候就没有初始化的时机了;
先父后子,可以这样理解,子类会引用父类的东西,那么必须先父后子。
静态初始化块不能访问非静态成员(即非静态实例变量和非静态方法)
}
}
结果:
父类--静态变量
父类--静态初始化块
子类--静态变量
子类--静态初始化块
-------------------
父类--变量
父类--初始化块
父类--构造器
-------------------
父类--变量
父类--初始化块
父类--构造器
子类--变量
子类--初始化块
子类--构造器
-------------------
父类--变量
父类--初始化块
父类--构造器
子类--变量
子类--初始化块
子类--构造器
7.构造方法私有化的应用:
packagestatic_Test;
classSinglet{
privateSinglet(){}//此处将构造方法进行封装
privatestaticSingletinstance=newSinglet();
publicstaticSingletgetInstance()
{
returninstance;
}
}
publicclasshh{
publicstaticvoidmain(Stringargs[]){
Singlets1=Singlet.getInstance();
Singlets2=Singlet.getInstance();
Singlets3=Singlet.getInstance();
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
}}
程序运行结果为:
static_Test.Singlet@17e4ca
static_Test.Singlet@17e4ca
static_Test.Singlet@17e4ca
由以上例子可以看出:
只要将构造方法私有化,就可以控制实例化对象的产生,这样的设计称为单例设计模式,即无论程序怎么运行,Singlet类永远只会有一个实例化对象存在。
8.内部类:
在外部访问内部类的格式:
外部类.内部类内部类对象名=外部类实例.new内部类();
例如:
Outerout=newOuter();
Outer.Innerin=out.newInner();
使用static申明的内部类就变成了外部类,但是用static申明的内部类不能访问非
static的外部类属性和方法;
在外部类方法中定义的内部类不能直接访问方法中的参数,如果方法中的参数要想被内部类所访问,则参数前面必须加上final关键字。
如果一个Java类的每个实例变量都被private修饰,并且为每个实例变量都提供了public修饰的setter和getter方法,那么这个类就是一个符合JavaBean规范的类。
因此JavaBean总是一个封装良好的类
不可变类:
意思是创建该类的实例后,该实例的实例变量是不可改变的。
如果要创建自定义的不可变类,可遵守如下规则:
1.使用private和final修饰符来修饰该类的成员变量;
2.提供带参数的构造器,用于根据传入参数来初始化类里的成员变量;
3.仅仅为该类的成员变量提供getter方法,不要为该类提供setter方法,
因为普通方法无法修改final修饰的成员变量;
4.如果有必要,重写equals()方法和hashcode()方法
9.一些规则:
(1)非静态方法可以访问静态成员,静态方法不能访问非静态成员;
(2)静态方法中不能使用this和super关键字,this()表示调用本类的构造方法,super()表示
调用父类的构造方法;
(3)static不能修饰构造方法。
static不能修饰接口,但是当接口定义在类的内部时,可以
用static修饰;
(4)如果父类方法用final修饰,则禁止子类覆写该方法;fina1类中的方法自动全部为fina1
类型的;对于final类中的成员,可以定义其为final,也可以不是final,子类无法直接
访问父类中使用private修饰的属性和方法,也无法覆写父类中的用private修饰的方法;
(5)final不能修饰抽象类,抽象类中的抽象方法绝不能被private修饰,因为其他类要继承
他,所以不能是私有的,否则不能被继承。
而抽象类中的成员变量和带有方法体的方法
可以被private修饰。
static不能修饰抽象类中的抽象方法,即static和abstract不能同时
修饰某个方法;抽象方法(前面用abstract修饰)只能定义在抽象类中,一般的方法也可
以定义在抽象类中;final修饰的成员变量必须显式地指定初始值,当final修饰类变量
时,必须在静态初始化块中指定初始值或者申明该类变量时指定初始值,而且只能在这
两个地方其中之一指定。
当final修饰实例变量时,必须在非静态初始化块、申明该实
例变量或构造器中指定初始值,而且只能在这三个地方其中之一指定;不管是类变量还
是实例变量,当他们被final修饰时,是不能在普通方法中为他们赋值的;如果方法的
参数用final修饰,那么方法体中就不能对形参进行赋值;
(6)继承抽象类的类应能完成这个抽象类中定义的所有方法(即具体实现这些抽象方法),
否则这个子类仍然是个抽象类;即使一个类中没有抽象方法也可以将该类申明为抽象
类。
(7)一个类只能继承一个父类,但却能同时实现多个接口,抽象类也可以实现多个接口。
在java中一个接口是不允许继承抽象类的,但是允许一个接口继承多个接口,例如:
interfaceAextendsB,C【A,B,C都为接口】;
(8)接口的修饰符只能用public或者abstract或者default修饰,接口中不能定义构造方法,
但抽象类中可以定义构造方法;接口不能继承类;
(9)接口中的方法必须定义为public访问权限,不写默认是public的,这是绝对不可改变
的,实现接口方法时,必须使用public修饰,因为接口里的方法都是public的,而实现
类重写父类方法时访问权限只能更大或者相等,所以实现类实现接口里的方法时只能
使用public访问权限;定义在接口中的常量具有固定的修饰符publicstaticfinal(连着的),
不管是否使用publicstaticfinal修饰,接口里的成员变量总是使用这三个修饰符来修饰。
申明在接口中的内部类自动为publicstatic的,也即接口中的内部类只能是静态内部类
(10)一个类要实现一个接口,就必须全部实现接口中的方法;只要接口中有一个方法没有
被类实现,那么这个类就是抽象类;
(11)一个抽象类中可以包含多个接口,一个接口中也可以包含多个抽象类;
(12)抽象类和接口不能直接用来产生对象,必须通过对象的多态性进行实例化操作;
(13)非静态成员方法被覆写后,可以通过super关键字在子类中进行调用;静态方法是
类级的,将无法使用super关键字进行调用;
(14)在静态方法内不允许访问非静态变量,不能出现this和supper,如果是static
修饰的内部类,那么内部类里面也不能出现this关键字;对static关键字而言,有一
条非常重要的规则:
类成员(包括方法、初始化块、内部类和枚举类)不能访问实例
成员(包括成员变量、方法、初始化块、内部类和枚举类)。
因为用static修饰的成
员是属于类的,类成员的作用域比实例成员的作用域更大,完全可能出现类成员初始
化完成,但实例成员还没有初始化的情况,如果允许类成员访问实例成员将会引起大
量错误;
(15)不能覆写父类的属性以及静态方法;如果子类定义了和父类同名的实例变量,则会发
生子类实例变量隐藏父类实例变量的情形,在子类定义的方法中可以通过super来访
问父类中被隐藏的实例变量。
子类不能继承父类的构造方法;只有方法能表现出多态
性,实例变量则不具备多态性
(16)父类中的static方法不能被子类覆写(可以通过编译,但是失去了多态性),但可
以被继承;而父类中的属性不管用什么修饰符都不能被子类覆写,但可以被继
承;private方法和属性不能被子类继承;
(17)如果一个类实现了多个接口,而且这几个接口中有相同的方法和相同的常量,那么
相同的常量可以通过【InterfaceName.常量名】的形式来访问,相同的方法则只需要实
现一次即可。
(18)如果外部类成员变量、内部类成员变量与内部类里某个方法的局部变量同名,假设这
三者都是Stringprop,那么在内部类中访问这三者的办法依次是:
OuterClass.this.prop、this.prop、prop。
局部内部类和匿名内部类都不是
类成员,要定义匿名内部类的前提:
内部类需要继承一个外部的类或者实现一个外部
的接口,但最多只能继承一个父类或者实现一个接口;执行下面代码,只创建了外部
类对象,还未创建内部类对象:
Outerouter=newOuter();
(19)匿名内部类不能是抽象类。
匿名内部类里面不能有构造方法【包括通过接口来创建匿
名内部类时】,因为匿名内部类没有类名,所以无法定义构造器,但匿名内部类可以
定义初始化块,可以通过实例初始化块来完成构造器需要完成的事情。
匿名内部类不
能定义任何静态成员、方法和类。
一个匿名内部类一定是在new的后面,用其隐含实
现一个接口或实现一个类;
(20)外部类的静态方法、静态代码块不能访问非静态内部类;
静态内部类可以包含静态成员也可以包含非静态成员。
静态内部类只能访问外部类的
静态成员,即使是静态内部类的非静态方法也不能访问外部类的非静态成员。
访问
静态内部类中的静态方法可以这样访问:
OuterClass.InnerClass.function();
创建内部类实例的方法:
Outer.Innerinner=newOuter().newInner();在
外部类中访问静态内部类中的静态成员变量prop的办法:
InnerClass.prop
(21)非静态内部类可以有子类,而且非静态内部类的子类不一定是内部类,它可以是一个
外部普通的类。
非静态内部类里不能有静态方法、静态成员变量、静态初始化块,但
可以包含普通初始化块。
如果非静态内部类中定义了静态成员变量,那么该内部类要
么被static修饰,要么该静态成员变量被定义为staticfinal;非静态内部类的成员只
在非静态内部类范围
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- JAVA 笔记 分析
![提示](https://static.bdocx.com/images/bang_tan.gif)