Java的语言特点是什么(java语言的主要特点是什么)
485
2022-05-29
B站高清回放地址:
【https://www.bilibili.com/video/BV1Bm4y1Q7Wt?spm_id_from=333.999.0.0】
目录
一、Java环境搭建与使用(Eclipse——1.6JDK)
二、主函数
三、变量类型
Java中简基本数据类型的转型:
Java中的高精度数:
四、运算符
一元运算符(一元运算符有1个操作数)
输出【false】
二元运算符(二元运算符有2个操作数)
三元运算符(三元运算符有3个操作数)
五、类型分析(堆栈)
1. 栈(stack)与堆(heap)都是Java用来在Ram(随机存取存储器)中存放数据的地方。
2. 栈的优势是,存取速度比堆要快,仅次于直接位于CPU中的寄存器。
3. Java中的数据类型有两种。
4.String是一个特殊的包装类数据。
5. 关于String str = "abc"的内部工作。
6. 数据类型包装类的值不可修改。
7. 结论与建议:
一、Java环境搭建与使用(Eclipse——1.6JDK)
-【https://download.csdn.net/download/feng8403000/69430455】·免费
解压即可用,非常方便。
二、主函数
基础结构
package Action;//包名 public class test {//类名 public static void main(String[] args) {//主函数 //花括号{}内是作用域 } }
三、变量类型
int:int为整数类型,存储的时候,用4个字节存储,范围为-2,147,483,648到2,147,483,647,在变量初始化的时候,int类型的默认值为0。
short:short也属于整数类型,在存储的时候,用2个字节存储,范围为-32,768到32,767,在变量初始化的时候,short类型的默认值为0,一般情况下,因为Java本身转型的原因,可以直接写为0。
long:long也属于整数类型,在存储的时候,用8个字节存储,范围为-9,223,372,036,854,775,808到9,223,372,036, 854,775,807,在变量初始化的时候,long类型的默认值为0L或0l,也可直接写为0。
byte:byte同样属于整数类型,在存储的时候,用1个字节来存储,范围为-128到127,在变量初始化的时候,byte类型的默认值也为0。
float:float属于实数类型,在存储的时候,用4个字节来存储,范围为32位IEEEE 754单精度范围,在变量初始化的时候,float的默认值为0.0f或0.0F,在初始化的时候可以写0.0。
double:double同样属于实数类型,在存储的时候,用8个字节来存储,范围为64位IEEE 754双精度范围,在变量初始化的时候,double的默认值为0.0。
char:char属于字符类型,在存储的时候用2个字节来存储,因为Java本身的字符集不是用ASCII码来进行存储,是使用的16位Unicode字符集,它的字符范围即是Unicode的字符范围,在变量初始化的时候,char类型的默认值为'u0000'。
boolean:boolean属于布尔类型,在存储的时候不使用字节,仅仅使用1位来存储,范围仅仅为0和1,其字面量为true和false,而boolean变量在初始化的时候变量的默认值为false。
通过包装类获取其最大值与最小值:
System.out.println(Byte.MAX_VALUE); System.out.println(Byte.MIN_VALUE); System.out.println(Short.MAX_VALUE); System.out.println(Short.MIN_VALUE); System.out.println(Integer.MAX_VALUE); System.out.println(Integer.MIN_VALUE); System.out.println(Long.MAX_VALUE); System.out.println(Long.MIN_VALUE);
浮点数属于科学计数法显示。
String:
字符串类,顾名思义,就是操作字符串的类。可以用来存储字符串。
3)相关介绍:
在Java基本类型在使用字面量赋值的时候,有几个简单的特性如下:
【1】当整数类型的数据使用字面量赋值的时候,默认值为int类型,就是直接使用0或者其他数字的时候,值的类型为int类型,所以当使用long a = 0这种赋值方式的时候,JVM内部存在数据转换。
【2】当实数类型的数据使用字面量赋值的时候,默认值为double类型,就是当字面两出现的时候,JVM会使用double类型的数据类型。 (*:以上两点在转型中进行详细说明。)
【3】从JDK 5.0开始,Java里面出现了自动拆箱解箱的操作,基于这点需要做一定的说明:
对应原始的数据类型,每种数据类型都存在一个复杂类型的封装类,分别为Boolean、Short、Float、Double、Byte、Int、Long、Character,这些类型都是内置的封装类,这些封装类(Wrapper)提供了很直观的方法,针对封装类需要说明的是,每种封装类都有一个xxxValue()的方法,通过这种方法可以把它引用的对象里面的值转化成为原始变量的值,不仅仅如此,每个封装类都还存在一个valueOf(String)的方法直接把字符串对象转换为相应的简单类型。 在JDK 5.0之前,没有存在自动拆解箱的操作,即Auto Box操作,所以在这之前是不能使用以下方式的赋值代码的:
Integer a = 0; //这种赋值方式不能够在JDK 1.4以及以下的JDK编译器中通过
但是JDK 5.0出现了自动拆解箱的操作,所以在JDK 5.0以上的编译器中,以上的代码是可以通过的,关于自动拆箱解箱我会另外用一篇1.4到5.0的升级加以详细说明。
Java中简基本数据类型的转型:
Java中的简单数据类型的转换分为两种:自动转换和强制转换
1)自动转换:
当一个较“小”的数据和较“大”的数据一起运算的时候,系统将自动将较“小”的数据转换为较“大”的数据,再进行运算。
在方法调用过程,如果实际参数较“小”,而函数的形参比较“大”的时候,除非有匹配的方法,否则会直接使用较“大”的形参函数进行调用。
2)强制转换:
将“大”数据转换为“小”数据时,可以使用强制类型转换,在强制类型转换的时候必须使用下边这种语句: int a = (int)3.14;
只是在上边这种类型转换的时候,有可能会出现精度损失。 关于类型的自动提升,遵循下边的规则: 所有的byte、short、char类型的值将提升为int类型; 如果有一个操作数是long类型,计算结果是long类型; 如果有一个操作数是float类型,计算结果是float类型;
如果有一个操作数是double类型,计算结果是double类型;
自动类型转换图如下:
byte->short(char)->int->long->float->double 如果是强制转换的时候,就将上边的图反过来
3)转换附加:
当两个类型进行自动转换的时候,需要满足条件:
【1】这两种类型是兼容的,
【2】目的类型的数值范围应该比源转换值的范围要大。而拓展范围就遵循上边的自动类型转换树,当这两个条件都满足的时候,拓展转换才会发生,而对于几个原始类型转换过程,根据兼容性boolean和char应该是独立的,而其他六种类型是可以兼容的,在强制转换过程,唯独可能特殊的是char和int是可以转换的,不过会使用char的ASCII码值比如: int a = (int)'a';
a的值在转换过后输出的话,值为97;也可以通过中文的char进行转换int类型。
Java中的高精度数:
Java提供了两个专门的类进行高精度运算:BigInteger与BigDecimal,虽然Java原始变量都具有对应的封装类型,但是这两个变量没有对应的原始类型,而是通过方法来提供这两种类型的一些运算,其含义为普通类型能够做的操作,这两个类型对应都有,只是因为精度过大可能效率不够高。至于这两个类的具体操作可以参考JDK的相关API文档。
关于数据类型的一些技巧:若要求精度的结果,尽量避免使用float和double:
float和double类型本身是为了做科学运算,即执行二进制浮点运算而设计,但是却不能提供完全精确的结果,所以在要求精度的数值中,避免使用float和double,float和double在货币运算中尤其不合适,要让float和double精确表达0.1也是不可能的事。测试一下下边这段代码就明白了:
System.out.println(3.02-0.01);
结果是不是出乎意料,这个结果并不是偶然,而是JVM本身设计的目的决定的。而要解决这个问题,最好的办法是使用BigDecimal、int或者long进行相关运算,特别是货币运算,使用BigDecimal代替double是一个很好的办法。 BigDecimal唯一的缺点在于:BigDecimal没有相对应的原始类型,所以在进行基本数值运算的时候,需要进行方法调用才能操作,这样会使得和我们的编程习惯不相符合,若使用int和long,就需要进行简单的封装运算。
所以在要求精度答案的计算任务里面,一般慎用float和double,如果在进行商务运算,并且要求四舍五入或者简单的舍入行为,使用BigDecimal可能更加方便。所以尽量避免在精度运算中使用float和double,特别是我们常用的货币运算。
四、运算符
一元运算符(一元运算符有1个操作数)
++,- -都是运算符
++,- -可分为前+,后+和前-,后减
如果++在后面,如:num++ +10;先参与运算,然后自身结果再加一
如果++在前面,如:++num +10;先自身加一,然后再参与运算
int num1=10; int num2=10; System.out.println(++num1); System.out.println(num2++);
!非,对表达式取反
!true=false
System.out.println(!true);
输出【false】
二元运算符(二元运算符有2个操作数)
【+-*/】四则运算·简单计算器
【%】取模运算·对12345,做各位上的数组做累加运算。
【&、|、&&、||、^】逻辑运算符·值交换·通过【&和|】判断一百分制成绩。
int a=5;//101 int b=7;//111 a=a^b;//两者不同量:010=2 System.out.println(a); b=a^b;//两者不同:101 System.out.println(b); a=a^b;//再进行两者不同取值:111 System.out.println(a);//二进制111 System.out.println(b);//二进制101
三元运算符(三元运算符有3个操作数)
三元运算符是软件编程中的一个固定格式,语法是“条件表达式?表达式1:表达式2”。使用这个算法可以使调用数据时逐级筛选。
表达式:“()? :”。
()中进行二元运算
?再运算,就形成三元运算符
int x = 10; int y = 5; int z; //如果x大于y 则是true,将x赋值给z; //如果x不大于y 则是false,将y赋值给z; z = (x > y) ? x : y; System.out.println("x = " + x); System.out.println("y = " + y); System.out.println("z = " + z);
五、类型分析(堆栈)
stack和haep都是内存的一部分
stack空间小,速度比较快, 用来放对象的引用
heap大,一般所有创建的对象都放在这里。
栈(stack):是一个先进后出的数据结构,通常用于保存方法(函数)中的参数,局部变量.
在java中,所有基本类型和引用类型都在栈中存储.栈中数据的生存空间一般在当前scopes内(就是由{...}括起来的区域).
堆(heap):是一个可动态申请的内存空间(其记录空闲内存空间的链表由操作系统维护),C中的malloc语句所产生的内存空间就在堆中.
在java中,所有使用new xxx()构造出来的对象都在堆中存储,当垃圾回收器检测到某对象未被引用,则自动销毁该对象.所以,理论上说java中对象的生存空间是没有限制的,只要有引用类型指向它,则它就可以在任意地方被使用.
1. 栈(stack)与堆(heap)都是Java用来在Ram(随机存取存储器)中存放数据的地方。
与C++不同,Java自动管理栈和堆,程序员不能直接地设置栈或堆。
2. 栈的优势是,存取速度比堆要快,仅次于直接位于CPU中的寄存器。
但缺点是,存在栈中的数据大小与生存期必须是确定的,缺乏灵活性。另外,栈数据可以共享,详见第3点。堆的优势是可以动态地分配内存大小,生存期也不必事先告诉编译器,Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是,由于要在运行时动态分配内存,存取速度较慢。
3. Java中的数据类型有两种。
一种是基本类型(primitive types), 共有8种,即int, short, long, byte, float, double, boolean, char(注意,并没有string的基本类型)。这种类型的定义是通过诸如int a = 3; long b = 255L;的形式来定义的,称为自动变量。值得注意的是,自动变量存的是字面值,不是类的实例,即不是类的引用,这里并没有类的存在。如int a = 3; 这里的a是一个指向int类型的引用,指向3这个字面值。这些字面值的数据,由于大小可知,生存期可知(这些字面值固定定义在某个程序块里面,程序块退出后,字段值就消失了),出于追求速度的原因,就存在于栈中。
另外,栈有一个很重要的特殊性,就是存在栈中的数据可以共享。假设我们同时定义:
int a = 3; int b = 3;
编译器先处理int a = 3;首先它会在栈中创建一个变量为a的引用,然后查找有没有字面值为3的地址,没找到,就开辟一个存放3这个字面值的地址,然后将a指向3的地址。接着处理int b = 3;在创建完b的引用变量后,由于在栈中已经有3这个字面值,便将b直接指向3的地址。
这样,就出现了a与b同时均指向3的情况。特别注意的是,这种字面值的引用与类对象的引用不同。
假定两个类对象的引用同时指向一个对象,如果一个对象引用变量修改了这个对象的内部状态,那么另一个对象引用变量也即刻反映出这个变化。
相反,通过字面值的引用来修改其值,不会导致另一个指向此字面值的引用的值也跟着改变的情况。
如上例,我们定义完a与b的值后,再令a=4;那么,b不会等于4,还是等于3。在编译器内部,遇到a=4;时,它就会重新搜索栈中是否有4的字面值,如果没有,重新开辟地址存放4的值;如果已经有了,则直接将a指向这个地址。因此a值的改变不会影响到b的值。
另一种是包装类数据,如Integer, String, Double等将相应的基本数据类型包装起来的类。这些类数据全部存在于堆中,Java用new()语句来显示地告诉编译器,在运行时才根据需要动态创建,因此比较灵活,但缺点是要占用更多的时间。
4.String是一个特殊的包装类数据。
即可以用String str = new String("abc");的形式来创建,也可以用String str = "abc";的形式来创建(作为对比,在JDK 5.0之前,你从未见过Integer i = 3;的表达式,因为类与字面值是不能通用的,除了String。而在JDK 5.0中,这种表达式是可以的!因为编译器在后台进行Integer i = new Integer(3)的转换!)。
前者是规范的类的创建过程,即在Java中,一切都是对象,而对象是类的实例,全部通过new()的形式来创建。Java中的有些类,如DateFormat类,可以通过该类的getInstance()方法来返回一个新创建的类,似乎违反了此原则。其实不然。该类运用了单例模式来返回类的实例,只不过这个实例是在该类内部通过new()来创建的,而getInstance()向外部隐藏了此细节。那为什么在String str = "abc";中,并没有通过new()来创建实例,是不是违反了上述原则?其实没有。
5. 关于String str = "abc"的内部工作。
Java内部将此语句转化为以下几个步骤:
(1)先定义一个名为str的对String类的对象引用变量:String str;
(2)在栈中查找有没有存放值为"abc"的地址,如果没有,则开辟一个存放字面值为"abc"的地址,接着创建一个新的String类的对象o,并将o的字符串值指向这个地址,而且在栈中这个地址旁边记下这个引用的对象o。如果已经有了值为"abc"的地址,则查找对象o,并返回o的地址。
(3)将str指向对象o的地址。
值得注意的是,一般String类中字符串值都是直接存值的。但像String str = "abc";这种场合下,其字符串值却是保存了一个指向存在栈中数据的引用!
为了更好地说明这个问题,我们可以通过以下的几个代码进行验证。
String str1 = "abc"; String str2 = "abc"; System.out.println(str1==str2); //true
注意,我们这里并不用str1.equals(str2);的方式,因为这将比较两个字符串的值是否相等。==号,根据JDK的说明,只有在两个引用都指向了同一个对象时才返回真值。而我们在这里要看的是,str1与str2是否都指向了同一个对象。
结果说明,JVM创建了两个引用str1和str2,但只创建了一个对象,而且两个引用都指向了这个对象。
我们再来更进一步,将以上代码改成:
String str1 = "abc"; String str2 = "abc"; str1 = "bcd"; System.out.println(str1 + "," + str2); //bcd, abc System.out.println(str1==str2); //false
这就是说,赋值的变化导致了类对象引用的变化,str1指向了另外一个新对象!而str2仍旧指向原来的对象。上例中,当我们将str1的值改为"bcd"时,JVM发现在栈中没有存放该值的地址,便开辟了这个地址,并创建了一个新的对象,其字符串的值指向这个地址。
事实上,String类被设计成为不可改变(final)的类。如果你要改变其值,可以,但JVM在运行时根据新值悄悄创建了一个新对象,然后将这个对象的地址返回给原来类的引用。这个创建过程虽说是完全自动进行的,但它毕竟占用了更多的时间。在对时间要求比较敏感的环境中,会带有一定的不良影响。
再修改原来代码:
String str1 = "abc"; String str2 = "abc"; str1 = "bcd"; String str3 = str1; System.out.println(str3); //bcd String str4 = "bcd"; System.out.println(str1 == str4); //true
str3这个对象的引用直接指向str1所指向的对象(注意,str3并没有创建新对象)。当str1改完其值后,再创建一个String的引用str4,并指向因str1修改值而创建的新的对象。可以发现,这回str4也没有创建新的对象,从而再次实现栈中数据的共享。
我们再接着看以下的代码。
String str1 = new String("abc"); String str2 = "abc"; System.out.println(str1==str2); //false
创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。
String str1 = "abc"; String str2 = new String("abc"); System.out.println(str1==str2); //false
创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。
以上两段代码说明,只要是用new()来新建对象的,都会在堆中创建,而且其字符串是单独存值的,即使与栈中的数据相同,也不会与栈中的数据共享。
6. 数据类型包装类的值不可修改。
不仅仅是String类的值不可修改,所有的数据类型包装类都不能更改其内部的值。
7. 结论与建议:
(1)我们在使用诸如String str = "abc";的格式定义类时,总是想当然地认为,我们创建了String类的对象str。担心陷阱!对象可能并没有被创建!唯一可以肯定的是,指向String类的引用被创建了。至于这个引用到底是否指向了一个新的对象,必须根据上下文来考虑,除非你通过new()方法来显要地创建一个新的对象。因此,更为准确的说法是,我们创建了一个指向String类的对象的引用变量str,这个对象引用变量指向了某个值为"abc"的String类。清醒地认识到这一点对排除程序中难以发现的bug是很有帮助的。
(2)使用String str = "abc";的方式,可以在一定程度上提高程序的运行速度,因为JVM会自动根据栈中数据的实际情况来决定是否有必要创建新对象。而对于String str = new String("abc");的代码,则一概在堆中创建新对象,而不管其字符串值是否相等,是否有必要创建新对象,从而加重了程序的负担。
(3)当比较包装类里面的数值是否相等时,用equals()方法;当测试两个包装类的引用是否指向同一个对象时,用==。
(4)由于String类的final性质,当String变量需要经常变换其值时,应该考虑使用StringBuffer类,以提高程序效率。
本节比较细致,希望能对大家有一定的帮助,祝大家蓝桥都能拿一个好成绩。
Java 面向对象编程
版权声明:本文内容由网络用户投稿,版权归原作者所有,本站不拥有其著作权,亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容,请联系我们jiasou666@gmail.com 处理,核实后本网站将在24小时内删除侵权内容。